Comme nous le savons tous, la série Zelda est l’une des meilleures séries de jeux jamais réalisée. En l'honneur de cela, laissez-nous jouer quelques chansons sur l'ocarina.

Défi:

Ecrivez un programme qui, à partir d’une chanson, sort la partition sur la sortie standard de cette chanson.

Contribution:

La chanson dont vous devez sortir le score sera donnée par une combinaison unique de trois caractères, comme indiqué ci-dessous:

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

Bonus chansons, -7% chacune:

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

Chanson en prime 2, -8%:

scs - Scarecrow's song 

Comme nous le savons tous, la chanson de Scarecrow est une chanson que vous composez vous-même. Cette chanson doit avoir huit notes. Générez une partition que vous composez vous-même, qui est différente de toutes les autres partitions.

Si vous décidez d'inclure toutes les chansons, le total de vos octets sera de -50%.

Sortie:

Les notes de la sortie sont symbolisées par les caractères suivants:

^
<
>
V
A

Produire un score au format suivant:

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

Une seule note par colonne est autorisée. Par souci de simplicité, j'ai ajouté une autre ligne aux quatre lignes d'origine.

Chaque note correspond à une ligne différente:

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

La sortie doit être écrite sur stdout. Les retours à la ligne sont autorisés.

Exemples:

Entrée (berceuse de Zelda):

zel

Sortie:

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

Entrée (Bolero de feu):

bof

Sortie:

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

Remarquez la feuille de triche:

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

Depuis que nous jouons au golf de code ocarina , le programme le plus court en octets gagne!

Références de chansons:

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

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

Pyth, 56,5 (113 octets - 6 × 7% - 8%)

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

Il contient des caractères non imprimables, voici donc un xxdhexdump réversible :

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

Vous pouvez également l' essayer en ligne .

Explication

Je stocke les morceaux dans des nombres en base 6, ré-encodés en base 1391423, puis en base 256 pour économiser de l'espace. J'ai dû choisir la base 6 car certaines chansons commencent par ^, et les chiffres ne peuvent pas vraiment commencer par un 0 après le décodage.

  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

Pas vraiment essayer de jouer au golf ici. Aller plus pour l'angle de beauté. Je pense que le programme principal a l'air vraiment soigné, une boîte rectangulaire parfaite cachée à droite.

Comme toujours, vous pouvez obtenir un meilleur rendu en vous exécutant $('pre').css('line-height',1)dans la console de votre navigateur.

                 ┌─────────────────────────┐
               ┌─┴─╖                     ┌─┴─╖
      ┌────────┤ · ╟─────────────────────┤ · ╟─────────────┐    ╔═════════╗   ╔════╗  ╔════╗
      │        ╘═╤═╝     ╔═════════╗     ╘═╤═╝ ╓───╖       │    ║ 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 ║
      ╘════╝ ╚════╝   ╚═══╝

Poursuivant dans la tradition de donner des noms de fonctions funciton consistant en un seul, étrange, rarement utilisé caractère Unicode, je pensais à ce que pourrait mieux représenter ce défi, et il me est apparu que Lien et Zelda (ou, si vous voulez, Légende de Zelda ) vous donne LZ , le digraphe minuscule ʫ (U + 02AB, sᴍᴀʟʟ ʟᴇᴛᴛᴇʀ ʟᴢ) semble donc approprié.

Explication

Comme expliqué dans l'article d'esolangs, le programme Funciton reçoit l'entrée encodée comme ce que j'appellerais «UTF-21», mais sous la forme d'un entier unique et gigantesque. Si je voulais utiliser ce nombre comme clé d'un hashmap (dictionnaire, tableau associatif), il me faudrait une fonction de hachage qui satisfait deux critères: un, c'est assez simple à implémenter dans Funciton, et deux, les 13 attendus les chaînes d'entrée donnent une valeur de hachage différente. La fonction de hachage la plus simple à laquelle je pouvais penser avait input % mune valeur de m. Par conséquent, j'ai essayé m= 13, 14, 15, etc. jusqu'à atteindre le plus petit entier pour lequel toutes les valeurs de hachage sont uniques. Il s'avère que ce nombre est 25.

Les valeurs de hachage sont:

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

Nous encodons chaque chanson en ayant un bit représentant la présence ou l’absence d’une note. Par exemple, la berceuse de Zelda serait codée comme suit:

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

sauf que les bits sont dans l'ordre inverse; la cellule en haut à gauche est dans le bit le moins significatif. Cela signifie que chaque chanson est longue de 40 bits.

Nous créons ainsi une table de hachage (moyennement rare) en prenant un nombre de 40 × 25 = 1000 bits et en plaçant le motif de bits de chaque chanson au bon endroit en fonction de sa valeur de hachage. Le nombre monstrueux dans le programme est exactement cette table de hachage.

Voici ce que chacun des chiffres restants signifie:

• 45= 0x2Dest le Unicode pour -.
• 1257283645609482190214660190: Ceci est la chaîne ^<>VAen UTF-21. Avec le recul, j'aurais pu utiliser 7 bits par caractère ici, ce qui raccourcissait le nombre, mais UTF-21 est si profondément traditionnel dans Funciton que cela ne m'est simplement pas venu à l'esprit.
• 2097151= 0x1FFFFF= (1 << 21) - 1. Utilisé pour obtenir le premier caractère de la chaîne ci-dessus.
• 20971565: C'est la chaîne -\nqui est ajoutée à la fin de chaque ligne.
  • Il peut sembler curieux que ce nombre et le précédent soient si semblables, mais si vous y réfléchissez, c'est parce que nous utilisons le format décimal et que le format Unicode \nest 10. Ce dernier nombre est (10 << 21) + 45.

Le programme se déroule maintenant comme suit:

• Le programme principal appelle ʫavec les 3 paramètres suivants:
  • B : La table de hachage, décalée à droite de 40 bits par la valeur de hachage de l'entrée. La chanson que nous voulons sortir est maintenant dans les 40 bits les moins significatifs.
  • c : la chaîne ^<>VA.
  • a : Le nombre 8.
• A chaque itération de ʫ,
  • si c n'est pas vide,
    • si un est non nul, regardez le bit fond de B . Sortie -, suivi d'un autre -s'il s'agit de zéro ou du premier caractère de c sinon. Décalez le droit B par un pour supprimer un bit et décrémenter un .
    • si a est égal à zéro, émettez -\n, puis coupez le premier caractère de c et démarrez une autre boucle avec a = 8.
  • si c est vide, nous avons terminé.

Python 2, 143,5 (287 octets - 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 grille est générée avec des tirets; puis indexé et remplacé par des notes.

Perl 5, 125 ( 320 260 250 octets -6x7% chansons en bonus -8% en chanson d'épouvantail)

Yay, enfin l'occasion d'expérimenter cette syntaxe de hachage 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)

Tester

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

Perl, 75 (150 octets - 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

En comptant le shebang comme 2, l'entrée est prise de stdin.

Utilisation de l'échantillon

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

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 Fait le travail.

Je pensais pouvoir battre Python en utilisant ces encodages (cela m’a pris beaucoup de temps ._.), Mais non. Ils ne sauvegardent pas encore beaucoup d'octets. Aucune suggestion?

Oui, c'est un moins devant le codage pour "ros". C’est parce que sa "feuille" se termine par le caractère correspondant 0à ma base 5, parce que cette astuce négative ne fonctionnerait pas pour les "chansons faciles" encodées en doublant ce qui est encodé s. Sauf si vous utilisez quotpeut-être, mais alors vous ne pouvez pas gérer p (-1)spécialement, car quot (-5) = 0, ainsi la négativité disparaîtrait. Peu importe.

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

Merci à Ismael Miguel et Blackhole pour leurs bonnes idées pour économiser davantage d'octets!

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

Après le print"-, il s’agit d’une insertion littérale d’un retour chariot. Il peut traduire deux octets dans Windows.

Toutes les chansons bonus, y compris la chanson de l'épouvantail, sont incluses.

Chaque chanson est représentée dans sept octets de code. J'aime la nouvelle notation car avec l'ancienne, j'aurais gagné un maigre point de bonus en tout!

Les dernières modifications font que PHP génère beaucoup d’avertissements, donc pour que tout soit bien rangé, ceux-ci sont détournés /dev/null.

Enregistrer sous zelda.phpet exécuter sur la ligne de commande:

$ 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 octets - 50%)

Supprimez quelques octets du leader Python actuel en utilisant la méthode d'impression à l'utilisation plutôt que la méthode de remplacement.

Essayez en ligne

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)

Courir:

> python3 loz.py
bof [return]

Sortie:

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

Ruby, rév 1, 192 - 50% = 96

Le golf comprend:

suppression des espaces entre groupes de lettres de la chaîne magique (et révision du dénominateur à la fin de la ligne /4). Suppression de quelques autres espaces inutiles.

conversion des séquences d'échappement en caractères uniques (l'échange de pile ne les affichera pas, donc j'ai mis ?comme espace réservé)

redéfinition de gcomme une chaîne unique contenant cinq exécutions de 17 -suivies de nouvelles lignes, au lieu d'un tableau de cinq chaînes 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, rév. 0, 223 - 50% = 111,5 (non golfé)

Le code d'entrée est réduit à 2 lettres. Si elle commence par un s, la sest supprimée, si elle commence par une lettre après s(uniquement applicable à zella dernière lettre, est supprimée et si elle commence par une lettre avant que sla lettre du milieu ne soit supprimée.

La chaîne magique (qui dans la version sans golf contient des espaces pour plus de clarté) contient les codes à 2 lettres suivis des données de musique. La recherche s'effectue à l'aide de l'opérateur de correspondance =~qui renvoie la position dans la chaîne.

Il existe exactement une chanson de 5, 7 et 8 notes (plus une note qui a également 8 notes). Celles-ci, ainsi qu’une chanson arbitraire de 6 notes rossont regroupées au début de la chaîne magique nde la position dans la chaîne peut être utilisée pour calculer le nombre de notes à jouer. csest serré avant bf, et avec la troncature lorsque le nombre dans nest arrondi, nous obtenons juste le calcul correct pour les deux. Après le quatrième groupe, toutes les chansons ont 6 notes. Par conséquent, nle nombre de notes par défaut est réduit à 6 par défaut.

Un tableau de -est configuré pour la sortie et les notes sont substituées une à une. Les données musicales requises sont extraites de la variable $'qui contient la partie de la chaîne magique originale à droite du match. De cette manière, les données non pertinentes sont ignorées.

Les notes sont encodées 3 à la fois dans la chaîne magique, juste après le code de chanson correspondant à 2 lettres. Ils sont extraits avec division par 5**(i%3)et un caractère gest mis à jour en conséquence. À la fin du programme gest imprimé.

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

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

Enregistre chaque note sous forme d’octet, chaque ligne ayant une longueur de 8 notes. Rappelle la représentation binaire puis remplace par les bons caractères.

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

Assez simple, il suffit de lire les chansons encodées en base-6.