Come tutti sappiamo, la serie Zelda è una delle migliori serie di giochi mai realizzate. In onore di ciò, suoniamo alcune canzoni sull'ocarina.

Sfida:

Scrivi un programma che, dato un brano, trasmette lo spartito allo stdout per quel particolare brano.

Ingresso:

La canzone di cui dovrai produrre lo spartito sarà data da una combinazione unica di tre caratteri come mostrato di seguito:

zel - Zelda's Lullaby
sas - Saria's Song
eps - Epona's Song
sos - Sun's Song
sot - Song of Time
sst - Song of Storms

Canzoni bonus, -7% ciascuna:

mof - Minuet of Forest
bof - Bolero of Fire
sow - Serenade of Water
nos - Nocturne of Shadow
ros - Requiem of Spirit
pol - Prelude of Light

Canzone bonus 2, -8%:

scs - Scarecrow's song 

Come tutti sappiamo, la canzone dello Spaventapasseri è una canzone che ti componi. Questa canzone deve avere otto note. Emetti un punteggio composto da te stesso che è diverso da tutti gli altri punteggi.

Se decidi di includere tutti i brani, il punteggio in byte sarà pari a un bonus del -50%.

Produzione:

Le note nell'output sono simboleggiate dai seguenti caratteri:

^
<
>
V
A

Stampa un punteggio nel seguente formato:

-^-^-^-^-^-^-^-^-
-<-<-<-<-<-<-<-<-
->->->->->->->->-
-V-V-V-V-V-V-V-V-
-A-A-A-A-A-A-A-A-

È consentita una sola nota per colonna. Per semplicità ho aggiunto un'altra riga alle quattro righe originali.

Ogni nota corrisponde a una riga diversa:

^: ----------------
<: ----------------
>: ----------------
V: ----------------
A: ----------------

L'output deve essere scritto su stdout. Sono consentite nuove righe finali.

Esempi:

Input (Lullaby di Zelda):

zel

Produzione:

---^-----^-------
-<-----<---------
----->----->-----
-----------------
-----------------

Input (Bolero di fuoco):

bof

Produzione:

-----------------
-----------------
--------->--->---
-V---V-----V---V-
---A---A---------

Nota il cheat sheet:

zel
<^><^>
sas
V><V><
eps
^<>^<>
sos
>V^>V^
sot
>AV>AV
sst
AV^AV^
mof
A^<><>
bof
VAVA>V>V
sow
AV>><
nos
<>>A<>V
ros
AVA>VA
pol
^>^><^

Dato che giochiamo al golf ocarina code, vince il programma più breve in byte!

Riferimenti alle canzoni:

http://www.thonky.com/ocarina-of-time/ocarina-songs

http://www.zeldadungeon.net/Zelda05-ocarina-of-time-ocarina-songs.php

Pyth, 56.5 (113 byte - 6 × 7% - 8%)

VtJ" ^<>VA"+K\-sm+?qNdNKK@LJj@jC"þØí§V^G¤×¹z1«bëë¶ñRõr¤çM"1391423xcs@LGjC"cc0Á:xqç÷\rS  Íó׺:9"lG3z6

Contiene caratteri non stampabili, quindi ecco un xxdhexdump reversibile :

0000000: 5674 4a22 205e 3c3e 5641 222b 4b5c 2d73  VtJ" ^<>VA"+K\-s
0000010: 6d2b 3f71 4e64 4e4b 4b40 4c4a 6a40 6a43  m+?qNdNKK@LJj@jC
0000020: 2207 fe85 d880 ed0e a756 5e47 8ba4 d7b9  "........V^G....
0000030: 7a9e 0531 ab1b 62eb ebb6 f112 52f5 72a4  z..1..b.....R.r.
0000040: e74d 2231 3339 3134 3233 7863 7340 4c47  .M"1391423xcs@LG
0000050: 6a43 229a 6317 6330 c13a 9278 71e7 10f7  jC".c.c0.:.xq...
0000060: 5c72 5309 87cd f3d7 ba3a 3922 6c47 337a  \rS......:9"lG3z
0000070: 36                                       6

Puoi anche provarlo online .

Spiegazione

Conservo i brani in numeri di base 6, ricodificato in base 1391423 e quindi in base 256 per risparmiare spazio. Ho dovuto scegliere la base 6 poiché alcune delle canzoni iniziano con ^, e i numeri non possono davvero iniziare con uno 0 dopo la decodifica.

  J" ^<>VA"                                                      save characters in J
 t                                                               discard the space
V                                                                loop over all characters
                               C"..."                            parse base256 string (songs) to int
                              j      1391423                     convert to base 1391423 (separate songs)
                                                   C"..."        parse base256 string (codes) to int
                                                  j      lG      convert to base-26
                                               @LG               replace indices by corresponding letters
                                              s                  concatenate
                                             c             3     chop to 3-character codes
                                            x               z    find index of input code
                             @                                   get correct song
                            j                                6   convert to base 6
                         @LJ                                     replace indices by corresponding ^<>VA
                m                                                map d over the above
                  ?qNdNK                                         take the current character if at its row,
                                                                 otherwise a dash
                 +      K                                        add a dash
               s                                                 concatenate
           +K\-                                                  add a dash and print

Funciton , 4322-50% = 2161

Non sto davvero cercando di giocare a golf qui. Andare di più per l'angolo della bellezza. Penso che il programma principale sembri davvero pulito, una scatola rettangolare perfetta nascosta a destra.

Come sempre, è possibile ottenere un rendering migliore eseguendo $('pre').css('line-height',1)nella console del browser.

                 ┌─────────────────────────┐
               ┌─┴─╖                     ┌─┴─╖
      ┌────────┤ · ╟─────────────────────┤ · ╟─────────────┐    ╔═════════╗   ╔════╗  ╔════╗
      │        ╘═╤═╝     ╔═════════╗     ╘═╤═╝ ╓───╖       │    ║ 1257283 ║ ┌─╢ 40 ║  ║ 25 ║
      │          │       ║ 2097151 ║       ├───╢ ʫ ╟───┐   │    ║ 6456094 ║ │ ╚════╝  ╚══╤═╝
    ┌─┴─╖        │       ╚════╤════╝     ┌─┴─╖ ╙─┬─╜ ┌─┴─╖ │    ║ 8219021 ║ │  ┌───╖   ┌─┴─╖
┌───┤ · ╟────────┴────┐       └─────┬────┤ · ╟───┴───┤ · ╟─┤    ║ 4660190 ║ └──┤ × ╟───┤ % ║
│   ╘═╤═╝             │            ┌┴┐   ╘═╤═╝       ╘═╤═╝ │    ╚════════╤╝    ╘═╤═╝   ╘═╤═╝
│     │               │            └┬┘     │           │   │    ╔═══╗  ┌─┴─╖  ┌──┴─╖   ╔═╧═╗
│     │  ╔═══╗ ┌────╖ │           ┌─┴─╖ ┌┐ │           │   │    ║ 8 ╟──┤ ʫ ╟──┤ >> ║   ║   ║
│     │  ║ 1 ╟─┤ >> ╟─┘       ┌───┤ ? ╟─┤├─┤           │   │    ╚═══╝  ╘═╤═╝  ╘══╤═╝   ╚═══╝
│     │  ╚═══╝ ╘══╤═╝         │   ╘═╤═╝ └┘ │           │   │    ╔════════════════╧═════════╗
│     │         ┌─┴─╖ ┌───╖ ┌─┴─╖ ┌─┴─╖  ╔═╧═╗         │   │    ║ 609678112368778425678534 ║
│   ┌─┴─────────┤ ʫ ╟─┤ ‼ ╟─┤ · ╟─┤ ‼ ║  ║ 1 ║         │   │    ║ 616189712722605554111376 ║
│   │           ╘═╤═╝ ╘═╤═╝ ╘═╤═╝ ╘═╤═╝  ╚═══╝         │   │    ║ 461573643915077926310571 ║
│   │             │     │     │   ╔═╧══╗               │   │    ║ 355541007599150245813976 ║
│   │   ╔══════╗  │     │     └───╢ 45 ║               │   │    ║ 426564826002362964111793 ║
│   │   ║ 2097 ║  │   ┌─┴─╖ ┌───╖ ╚════╝               │   │    ║ 714054902293682079346275 ║
│   │   ║ 1565 ║  └───┤ · ╟─┤ ♭ ╟─┐                    │   │    ║ 663973372550500581508544 ║
│   │   ╚═╤════╝      ╘═╤═╝ ╘═══╝ ├────────────────────┘   │    ║ 874263187322344354338195 ║
│   │   ┌─┴─╖         ┌─┴─╖       │                        │    ║ 642609790172899326178321 ║
│   │   │ ‼ ╟─────────┤ ? ╟───────┘                        │    ║ 071643306454414932126243 ║
│   │   ╘═╤═╝         ╘═╤═╝                                │    ║ 308860823981077902637848 ║
│ ┌─┴─╖ ┌─┴─╖ ╔═══╗   ┌─┴─╖                                │    ║ 322657399386789617074176 ║
└─┤ · ╟─┤ ʫ ╟─╢ 8 ║ ┌─┤ ? ╟────────────────────────────────┘    ╚══════════════════════════╝
  ╘═╤═╝ ╘═╤═╝ ╚═══╝ │ ╘═╤═╝
    │ ┌───┴╖ ╔════╗ │ ╔═══╗
    └─┤ >> ╟─╢ 21 ║ └─╢ 0 ║
      ╘════╝ ╚════╝   ╚═══╝

Continuando nella tradizione di dare nomi di funzioni di Funciton costituiti da un singolo, strano, personaggio Unicode usato raramente, ho pensato a cosa potesse rappresentare al meglio questa sfida, e mi è venuto in mente che Link e Zelda (o, se vuoi, Legend of Zelda ) ti dà LZ , quindi il digrafo minuscolo ʫ (U + 02AB, ʟᴀᴛɪɴ sᴍᴀʟʟ ʟᴇᴛᴛᴇʀ ʟᴢ ᴅɪɢʀᴀᴘʜ) sembra appropriato.

Spiegazione

Come spiegato nell'articolo di esolang, il programma Funciton riceve l'input codificato come quello che chiamerei "UTF-21", ma come un singolo intero enorme. Se volessi usare questo numero come chiave per una hashmap (dizionario, array associativo), avrei bisogno di una funzione hash che soddisfi due criteri: uno, è abbastanza semplice da implementare a Funciton e due, tutti e 13 previsti le stringhe di input danno un valore di hash diverso. La funzione hash più semplice a cui potevo pensare era input % mper un certo valore m. Pertanto, ho provato m= 13, 14, 15, ecc. Finché non sono arrivato al numero intero più piccolo per il quale tutti i valori di hash sono univoci. Si scopre che questo numero è 25.

I valori di hash sono:

zel =  6
sas = 19
eps = 10
sos = 22
sot =  1
sst =  9
mof = 14
bof =  3
sow = 13
nos = 17
ros = 21
pol = 16
scs = 23

Codifichiamo ogni brano facendo in modo che un bit rappresenti la presenza o l'assenza di una nota. Ad esempio, la ninna nanna di Zelda verrebbe codificata come segue:

---^-----^------- = 01001000
-<-----<--------- = 10010000
----->----->----- = 00100100
----------------- = 00000000
----------------- = 00000000

tranne che i bit sono nell'ordine opposto; la cella in alto a sinistra è nel bit meno significativo. Ciò significa che ogni brano è lungo 40 bit.

Creiamo così una tabella hash (moderatamente sparsa) prendendo un numero 40 × 25 = 1000 bit e posizionando il pattern di bit per ogni song nel posto giusto in base al suo valore di hash. Il numero mostruoso nel programma è esattamente questa tabella hash.

Ecco cosa significano ciascuno dei numeri rimanenti:

• 45= 0x2Dè Unicode per -.
• 1257283645609482190214660190: Questa è la stringa ^<>VAin UTF-21. Con il senno di poi avrei potuto usare 7 bit per personaggio qui, rendendo il numero più breve, ma UTF-21 è così profondamente tradizionale a Funciton che semplicemente non mi è venuto in mente.
• 2097151= 0x1FFFFF= (1 << 21) - 1. Usato per ottenere il primo carattere dalla stringa sopra.
• 20971565: Questa è la stringa -\n, che viene aggiunta alla fine di ogni riga.
  • Può sembrare curioso che questo numero e il precedente appaiano così simili, ma se ci pensate, è perché stiamo usando il decimale e Unicode \nsembra essere 10. L'ultimo numero è (10 << 21) + 45.

Il programma ora procede come segue:

• Il programma principale chiama ʫcon i seguenti 3 parametri:
  • B : La tabella hash, spostata a destra di 40 bit volte il valore hash dell'input. La canzone che vogliamo emettere è ora nei 40 bit meno significativi.
  • c : la stringa ^<>VA.
  • a : il numero 8.
• In ogni iterazione di ʫ,
  • se c non è vuoto,
    • se una non è pari a zero, sguardo alla punta inferiore della B . Output -, seguito da un altro -se è zero o il primo carattere di c altrimenti. Spostare a destra B di uno per rimuovere un bit e diminuire a .
    • se a è zero, emettere -\n, quindi tagliare il primo carattere da c e avviare un altro ciclo con a = 8.
  • se c è vuoto, abbiamo finito.

Python 2, 143.5 (287 byte - 50%)

i='^<>VA'
u=dict(zel="<^>"*2,sas="V><"*2,eps="^<>"*2,sos=">V^"*2,sot=">AV"*2,sst="AV^"*2,mof="A^<><>",bof="VAVA>V>V",sow="AV>><",nos="<>>A<>V",ros="AVA>VA",pol="^>^><^",scs="<"*8)[raw_input()]
r=[17*['-']for _ in[1]*5]
x=0
for g in u:r[i.find(g)][x*2+1]=g;x+=1
for h in r:print''.join(h)

La griglia viene generata con trattini; quindi indicizzato e sostituito con note.

Perl 5, 125 ( 320 260 250 byte -6x7% canzoni bonus -8% canzone spaventapasseri)

Sì, finalmente un'opportunità per sperimentare quella sintassi hash Perlish.

$_=pop;@B={qw(zel <^><^> sas V><V>< eps ^<>^<> sos >V^>V^ sot >AV>AV sst AV^AV^ mof A^<><> bof VAVA>V>V sow AV>>< nos <>>A<>V ros AVA>VA pol ^>^><^ scs <^V>>V^<)}->{$_}=~/./g;map{@L=('-')x17;for$i(0..@B){$L[1+2*$i]=$_,if$B[$i]eq$_}say@L}qw(^ < > V A)

Test

$ perl -M5.010 ocarina.pl scs
---^---------^---
-<-------------<-
------->->-------
-----V-----V-----
-----------------

Perl, 75 (150 byte - 50%)

#!perl -nl
$i=vec~$_,0,32;print+qw(- - ^ < > V A)[0,map{vec('w2$$W4F4w7DeweTFwR$Ew$C2wVdeVe3cw4B#EEVVwC5Tw44bwR&e',$i/480%15*8-$_,4)==$.&&$.,0}1..8]while$.++<6

Contando lo shebang come 2, l'input viene preso dallo stdin.

Utilizzo del campione

$ echo zel | perl zelda.pl
---^-----^-------
-<-----<---------
----->----->-----
-----------------
-----------------

$ echo bof | perl zelda.pl
-----------------
-----------------
--------->--->---
-V---V-----V---V-
---A---A---------

$ echo scs | perl zelda.pl
-----------------
---<-<-<---------
-----------------
-----------V-V---
-A-------A-----A-

Haskell, 344-50% = 172 byte

import Data.List
s"zel"=82
s"sas"=69
s"eps"=86
s"sos"=48
s"sot"=128
s"sst"=50
z"mof"=11055
z"bof"=373854
z"sow"=1720
z"nos"=73217
z"ros"= -12730
z"pol"=4791
z"scs"=304236
z n=s n*126
p n|n*n== -n="   "|0<1="A^<>V"!!(n`mod`5):p(n`div`5)
o=putStr.unlines.transpose.(l:).concatMap(\c->[map(e c)"^<>VA",l]).take 8.p.z
e c d|c==d=c|0<1='-'
l="-----"

o fa il lavoro.

Pensavo di poter battere Python usando queste codifiche (mi ci è voluto molto tempo ._.), Ma no. Non salvano ancora molti byte. Eventuali suggerimenti?

Sì, questo è un segno negativo di fronte alla codifica per "ros". Questo perché il suo "foglio" termina con il personaggio che significa 0nella mia base-5, perché questo trucco negativo non funzionerebbe per le "canzoni facili" codificate raddoppiando ciò che è codificato s. A meno che tu non usi quotforse, ma poi non puoi gestirlo in modo p (-1)speciale, poiché quot (-5) = 0la negatività svanirebbe. Qualunque cosa.

PHP: 130 byte (260 270 279 byte - 6 × 7% - 8%)

Grazie a Ismael Miguel e Blackhole per alcune grandi idee per salvare più byte!

<?php $f=str_split;for($z='*^<>VA';++$i<6;print"-
")foreach($f(base_convert(substr(current(preg_grep("/^$argv[1]/",$f(bofttmmeps8jf0mofvff0nosfnfopol99d0rosyxt0sasrgk0scs8m8msosm9p0sotnry0sowylc0sstybp0zeldk90,7))),-4),36,6),1)as$c)echo$i-$c?'--':'-'.$z[$c-0];

Dopo il print"-, questo è un inserimento letterale di un ritorno a capo. Può tradurre in due byte in Windows.

Sono inclusi tutti i brani bonus, incluso il brano dello Spaventapasseri.

Ogni brano è rappresentato in sette byte di codice. Mi piace il nuovo punteggio perché con il vecchio punteggio avrei guadagnato solo un magro punto bonus in totale!

Le recenti modifiche fanno sì che PHP generi molti avvisi, quindi per mantenere le cose belle e in ordine, vengono deviate /dev/null.

Salva come zelda.phped esegui dalla riga di comando:

$ php zelda.php zel 2> /dev/null
---^-----^-------                                                                                                                                   
-<-----<---------                                                                                                                                   
----->----->-----                                                                                                                                   
-----------------                                                                                                                                   
-----------------

$ php zelda.php bof 2> /dev/null                                                                                                                            
-----------------                                                                                                                                   
-----------------                                                                                                                                   
--------->--->---                                                                                                                                   
-V---V-----V---V-                                                                                                                                   
---A---A--------- 

$ php zelda.php scs 2> /dev/null                                                                                                                          
-^-------^-------                                                                                                                                   
---<-------<-----                                                                                                                                   
----->------->---                                                                                                                                   
-------V-------V-                                                                                                                                   
-----------------

Python 3 - 138.5 ( 292 280 277 byte - 50%)

Hai eliminato alcuni byte dall'attuale leader di Python mentre esegui il metodo print-as-you-go anziché il metodo di sostituzione.

Prova online

s=dict(zel="<^><^>",sas="V><V><",eps="^<>^<>",sos=">V^>V^",sot=">AV>AV",sst="AV^AV^",mof="A^<><>",bof="VAVA>V>V",sow="AV>><",nos="<>>A<>V",ros="AVA>VA",pol="^>^><^",scs="AV><^AV>")[input()]
s+=" "*8
for c in "^<>VA":
 o="-"
 for x in range(8):o+=["--",c+"-"][s[x]==c]
 print(o)

Correre:

> python3 loz.py
bof [return]

Produzione:

-----------------
-----------------
--------->--->---
-V---V-----V---V-
---A---A---------

Rubino, giro 1, 192-50% = 96

Il golf include:

rimozione di spazi bianchi tra gruppi di lettere nella stringa magica (e revisione del denominatore alla fine della riga a /4 .) Rimozione di alcuni altri spazi bianchi non necessari.

conversione delle sequenze di escape in singoli caratteri (lo scambio di stack non li visualizzerà, quindi ho inserito ?come segnaposto)

ridefinizione di gcome una singola stringa contenente -cinque sequenze di 17 seguite da nuove righe, anziché una matrice di cinque stringhe di 17-

s=gets.chop
s[?s<=>s[0]]=''
n=("owEkrswuns=;gcsbfbYuze33as&&es77os??otaast??mf?9pl
?"=~/#{s}/)/4
g=(?-*17+'
')*5
(n<4? n+5:6).times{|i|x=$'[i/3].ord/5**(i%3)%5;g[x*18+i*2+1]='^<>VA'[x]}
puts g

Rubino, giro 0, 223-50% = 111,5 (non bruciato)

Il codice di input è ridotto a 2 lettere. Se inizia con una s, sviene eliminata, se inizia con una lettera dopo s(si applica solo zell'ultima lettera e se inizia con una lettera prima sche venga eliminata la lettera centrale.

La stringa magica (che nella versione non golfata contiene spazi per chiarezza) contiene i codici di 2 lettere seguiti dai dati musicali. Viene cercato utilizzando l'operatore di corrispondenza=~ che restituisce la posizione nella stringa.

Esiste esattamente una canzone di 5, 7 e 8 note (più scs che ha anche 8 note). Queste, insieme a una canzone di 6 note arbitraria, rossono raggruppate all'inizio della stringa magica in modo che il valore di ndato da la posizione nella stringa può essere utilizzata per calcolare il numero di note da suonare. csviene compresso in precedenza bfe con il troncamento quando il numero in nviene arrotondato per difetto otteniamo il calcolo corretto per entrambi. Dopo il quarto cluster, tutte le canzoni hanno 6 note, quindi se nè grande il numero di note viene ridotto a un valore predefinito di 6.

Un array di -è impostato per l'output e le note vengono sostituite una per una. I dati musicali richiesti vengono estratti dalla variabile $'che contiene la parte della stringa magica originale a destra della corrispondenza. In questo modo, i dati irrilevanti vengono ignorati.

Le note sono codificate 3 alla volta nella stringa magica, subito dopo il relativo codice del brano di 2 lettere. Vengono estratti con divisione per 5**(i%3)e un carattere in gviene aggiornato di conseguenza. Alla fine del programma gviene stampato.

s=gets.chop
s[?s<=>s[0]]=''
n=("owEk rswu ns=;g csbfbYu ze33 as&& es77 os\21\21 otaa st\23\23 mf\35\71 pl\n\a"=~/#{s}/)/5

g=(0..4).map{'-'*17}
(n<4? n+5 : 6).times{|i|x=$'[i/3].ord/5**(i%3)%5;g[x][i*2+1]='^<>VA'[x]}
puts g

Python 2, 141,5 byte -50% (283 byte)

s='D  2)AE0*  A2)D  AD )2 A  )D2A 0,"!A D2) A  (2EA"4H !A )2D A 1F`(A)2D  A  p\xc5*'.split("A")['sst pol zel sos sot sow sas ros mof scs nos eps bof'.split().index(raw_input())]
for c,n in zip(s,"^<>VA"):print"-".join([("-"+n)[i>"0"]for i in bin((ord(c)-32)%255)[2:].zfill(8)][::-1])

Memorizza ogni nota come byte poiché ogni riga è lunga 8 note. Richiama la rappresentazione binaria e quindi sostituisce con i caratteri giusti.

Lua, 249 byte - 50% = 124,5

w=io.write for j=1,5 do n={sst=41881,pol=44915,zel=30814,sos=42315,sot=17577,sow=5953,sas=35588,ros=11065,mof=29335,nos=122170,eps=29729,bof=719576,scs=999999}[...]for i=1,8 do d=n%6 n=(n-d)/6 c=d==6-j and'AV><^':sub(d,d)or'-'w('-',c)end w('-\n')end

Abbastanza semplice, rilegge solo brani codificati come numeri di base 6.