Como todos sabemos, a série Zelda é uma das melhores séries de jogos já feitas. Em homenagem a isso, vamos tocar algumas músicas na ocarina.

Desafio:

Escreva um programa que, dada uma música, produza a pontuação stdout para essa música em particular.

Entrada:

A música da qual você terá que produzir a partitura será apresentada por uma combinação única de três caracteres, como mostrado abaixo:

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

Músicas bônus, -7% cada:

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

Música bônus 2, -8%:

scs - Scarecrow's song 

Como todos sabemos, a música do Espantalho é uma música que você se compõe. Essa música precisa ter oito notas. Crie uma pontuação que você compõe, diferente de todas as outras.

Se você decidir incluir todas as músicas, isso totalizará um bônus de -50% na sua pontuação de bytes.

Saída:

As notas na saída são simbolizadas pelos seguintes caracteres:

^
<
>
V
A

Crie uma pontuação no seguinte formato:

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

Apenas uma nota por coluna é permitida. Por uma questão de simplicidade, adicionei outra linha às quatro linhas originais.

Cada nota corresponde a uma linha diferente:

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

A saída deve ser gravada em stdout. Novas linhas à direita são permitidas.

Exemplos:

Entrada (Canção de ninar de Zelda):

zel

Saída:

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

Entrada (Bolero de Fogo):

bof

Saída:

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

Nota cábula:

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
^>^><^

Como jogamos o código ocarina golf, o programa mais curto em bytes vence!

Referências de músicas:

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

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

Pitão, 56,5 (113 bytes - 6 × 7% - 8%)

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

Ele contém caracteres não imprimíveis, então aqui está um xxdhexdump reversível :

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

Você também pode experimentá-lo online .

Explicação

Eu guardo as músicas em números de base 6, recodificadas para a base 1391423 e depois a base 256 para economizar espaço. Eu tive que escolher a base 6, já que algumas músicas começam ^, e os números não podem realmente começar com um 0 após a decodificação.

  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

Função , 4322 - 50% = 2161

Não estou realmente tentando jogar golfe aqui. Indo mais pelo ângulo da beleza. Eu acho que o programa principal parece realmente limpo, uma caixa retangular perfeita escondida à direita.

Como sempre, você pode obter uma melhor renderização executando $('pre').css('line-height',1)no console do navegador.

                 ┌─────────────────────────┐
               ┌─┴─╖                     ┌─┴─╖
      ┌────────┤ · ╟─────────────────────┤ · ╟─────────────┐    ╔═════════╗   ╔════╗  ╔════╗
      │        ╘═╤═╝     ╔═════════╗     ╘═╤═╝ ╓───╖       │    ║ 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 na tradição de atribuir nomes de funções ao Funciton que consistem em um único caractere Unicode estranho, raramente usado, pensei no que poderia representar melhor esse desafio, e me ocorreu que Link e Zelda (ou, se você quiser, Legend of Zelda ) fornece LZ , então o dígrafo em minúsculas ʫ (U + 02AB, ʟᴀᴛɪɴ sᴍᴀʟʟ ʟᴇᴛᴛᴇʀ ʟᴢ ᴅɪɢʀᴀᴘʜ) parece apropriado.

Explicação

Conforme explicado no artigo da esolangs, o programa Funciton recebe a entrada codificada como o que eu chamaria de "UTF-21", mas como um único número inteiro humongo. Se eu quisesse usar esse número como chave para um hashmap (dicionário, matriz associativa), precisaria de uma função hash que atenda a dois critérios: um, é simples de implementar no Funciton e dois, todos os 13 esperados seqüências de entrada fornecem um valor de hash diferente. A função hash mais simples que eu conseguia pensar era input % mcom algum valor m. Portanto, tentei m= 13, 14, 15 etc. até chegar ao menor número inteiro para o qual todos os valores de hash são exclusivos. Acontece que esse número é 25.

Os valores de hash são:

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

Codificamos cada música fazendo com que um bit represente a presença ou ausência de uma nota. Por exemplo, a canção de ninar de Zelda seria codificada da seguinte maneira:

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

exceto que os bits estão na ordem oposta; a célula superior esquerda está no bit menos significativo. Isso significa que cada música tem 40 bits.

Assim, criamos uma tabela de hash (moderadamente esparsa) pegando um número de 40 × 25 = 1000 bits e colocando o padrão de bits para cada música no lugar certo, de acordo com seu valor de hash. O número monstruoso no programa é exatamente essa tabela de hash.

Aqui está o que cada um dos números restantes significa:

• 45= 0x2Dé o Unicode para -.
• 1257283645609482190214660190: Esta é a string ^<>VAem UTF-21. Em retrospectiva, eu poderia ter usado 7 bits por caractere aqui, diminuindo o número, mas o UTF-21 é tão profundamente tradicional no Funciton que simplesmente não me ocorreu.
• 2097151= 0x1FFFFF= (1 << 21) - 1. Usado para obter o primeiro caractere da string acima.
• 20971565: Esta é a string -\n, que é anexada ao final de cada linha.
  • Pode parecer curioso que esse número e o anterior pareçam tão semelhantes, mas se você pensar sobre isso, é porque estamos usando decimal e o Unicode \né 10. Esse último número é (10 << 21) + 45.

O programa agora segue o seguinte:

• O programa principal chama ʫcom os 3 parâmetros a seguir:
  • B : A tabela de hash deslocou para a direita 40 bits vezes o valor de hash da entrada. A música que queremos produzir está agora nos 40 bits menos significativos.
  • c : a string ^<>VA.
  • a : O número 8.
• Em cada iteração de ʫ,
  • se c não estiver vazio,
    • Se um não é zero, olhar para o bit inferior do B . Saída -, seguida por outra -se for zero ou o primeiro caractere de c, caso contrário. Desloque B para a direita um para remover um bit e diminua a .
    • se a for zero, faça a saída -\ne retire o primeiro caractere de c e inicie outro loop com a = 8.
  • se c estiver vazio, terminamos.

Python 2, 143,5 (287 bytes - 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)

A grade é gerada com traços; depois indexados e substituídos por notas.

Perl 5, 125 ( 320 260 250 Bytes -6x7% em músicas bônus -8% em músicas de espantalho)

Bem, finalmente, uma oportunidade de experimentar essa sintaxe de 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)

Teste

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

Perl, 75 (150 bytes - 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 o shebang como 2, a entrada é obtida de stdin.

Uso da amostra

$ 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 bytes

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 faz o trabalho.

Pensei que poderia vencer o Python usando essas codificações (demorei muito tempo ._.), Mas não. Eles ainda não salvam muitos bytes ainda. Alguma sugestão?

Sim, isso é um sinal de menos na frente da codificação para "ros". Isso porque sua 'folha' termina com o caractere que significa 0na minha base 5, porque esse truque negativo não funcionaria para as 'músicas fáceis' codificadas dobrando o que está codificado s. A menos que você use quot, talvez, mas então você não pode lidar p (-1)especialmente, pois quot (-5) = 0a negatividade desaparecerá. Tanto faz.

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

Obrigado a Ismael Miguel e Blackhole por algumas ótimas idéias para economizar mais bytes!

<?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];

Após o print"-, esta é uma inserção literal de um retorno de carro. Pode traduzir para dois bytes no Windows.

Todas as músicas bônus, incluindo a música do Espantalho, estão incluídas.

Cada música é representada em sete bytes de código. Eu gosto da nova pontuação, porque com a pontuação antiga eu teria ganho apenas um ponto de bônus escasso no geral!

As edições recentes fazem com que o PHP gere muitos avisos; portanto, para manter as coisas organizadas, essas são desviadas /dev/null.

Salve como zelda.phpe execute na linha de 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 bytes - 50%)

Raspou alguns bytes do líder atual do Python enquanto fazia o método de impressão conforme o uso, em vez do método de substituição.

Experimente on-line

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)

Corre:

> python3 loz.py
bof [return]

Saída:

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

Ruby, rev. 1, 192 - 50% = 96

Golfe inclui:

remoção de espaço em branco entre grupos de letras na sequência mágica (e revisão do denominador no final da linha para /4.) Remoção de outros espaços em branco desnecessários.

conversão das seqüências de escape em caracteres únicos (a troca de pilhas não os exibirá, então eu coloquei ?como espaço reservado)

redefinição de gcomo uma única sequência contendo cinco execuções de 17 -seguidas por novas linhas, em vez de uma matriz de cinco seqüências de 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

Ruby, rev. 0, 223 - 50% = 111,5 (não destruído)

O código de entrada é reduzido para 2 letras. Se começar com um s, o sserá excluído, se iniciar com uma letra depois s(somente aplicável à zelúltima letra será excluída e se iniciar com uma letra antes sda exclusão da letra do meio.

A seqüência mágica (que na versão não destruída contém espaços para maior clareza) contém os códigos de 2 letras seguidos pelos dados da música. Ele é pesquisado usando o operador match, =~que retorna a posição na string.

Há exatamente uma música, cada uma com 5, 7 e 8 notas (mais scs que também possui 8 notas). Estas, juntamente com uma música arbitrária de 6 notas, rossão agrupadas no início da sequência mágica, de modo que o valor ndado por a posição na corda pode ser usada para calcular o número de notas para tocar. csé espremido antes bfe, com o truncamento quando o número né arredondado para baixo, apenas obtemos o cálculo correto para ambos. Após o quarto cluster, todas as músicas têm 6 notas; portanto, se nfor grande, o número de notas será reduzido para o padrão 6.

Uma matriz de -é configurada para saída e as notas são substituídas uma a uma. Os dados musicais necessários são extraídos da variável $'que contém a parte da sequência mágica original à direita da partida. Dessa maneira, dados irrelevantes são ignorados.

As notas são codificadas 3 de cada vez na sequência mágica, logo após o código da música relevante de duas letras. Eles são extraídos com divisão por 5**(i%3)e um caractere gé atualizado de acordo. No final do programa gé impresso.

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 bytes -50% (283 bytes)

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])

Armazena cada nota como um byte, pois cada linha possui 8 notas. Recupera a representação binária e substitui pelos caracteres corretos.

Lua, 249 bytes - 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

Muito simples, apenas lê as músicas codificadas como números base-6.