Jak wszyscy wiemy, seria Zelda jest jedną z najlepszych serii gier, jakie kiedykolwiek stworzono. Na cześć tego, zagrajmy kilka piosenek na ocarinie.

Wyzwanie:

Napisz program, który, biorąc pod uwagę piosenkę, wyprowadza wynik na standardowe wyjście dla tego konkretnego utworu.

Wejście:

Piosenka, z której będziesz musiał wydać wynik, otrzyma unikalna kombinacja trzech znaków, jak pokazano poniżej:

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

Pieśni dodatkowe, po -7%:

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

Pieśń dodatkowa 2, -8%:

scs - Scarecrow's song 

Jak wszyscy wiemy, piosenka Scarecrow to piosenka, którą sam komponujesz. Ta piosenka musi mieć osiem nut. Wykonaj wynik, który sam skomponujesz, który różni się od wszystkich innych wyników.

Jeśli zdecydujesz się dołączyć wszystkie utwory, będzie to łącznie -50% premii do twojego wyniku w bajtach.

Wynik:

Notatki na wydruku są symbolizowane przez następujące znaki:

^
<
>
V
A

Wynik w następującym formacie:

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

Dozwolona jest tylko jedna nuta na kolumnę. Dla uproszczenia dodałem kolejny wiersz do oryginalnych czterech wierszy.

Każda nuta odpowiada innemu rzędowi:

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

Dane wyjściowe należy zapisać na standardowe wyjście. Końcowe znaki nowej linii są dozwolone.

Przykłady:

Wejście (Kołysanka Zelda):

zel

Wynik:

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

Wejście (Bolero ognia):

bof

Wynik:

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

Uwaga ściągawka:

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

Ponieważ gramy w golfa ocarina code, wygrywa najkrótszy program w bajtach!

Piosenki o referencjach:

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

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

Pyth, 56,5 (113 bajtów - 6 × 7% - 8%)

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

Zawiera znaki niedrukowalne, więc oto odwracalny xxdzrzut heksowy:

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

Możesz także spróbować online .

Wyjaśnienie

Przechowuję utwory w liczbach base-6, ponownie zakodowanych w bazie 1391423, a następnie w bazie 256, aby zaoszczędzić miejsce. Musiałem wybrać bazę 6, ponieważ niektóre utwory zaczynają się od ^, a liczby nie mogą zaczynać się od 0 po dekodowaniu.

  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

Naprawdę nie próbuję tutaj grać w golfa. Więcej pod kątem piękna. Myślę, że główny program wygląda naprawdę schludnie, idealne prostokątne pudełko schowane po prawej stronie.

Jak zawsze, możesz uzyskać lepsze renderowanie, wykonując $('pre').css('line-height',1)w konsoli przeglądarki.

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

Kontynuując tradycję nadawania nazw funkcjom Funciton składającym się z jednego, dziwnego, rzadko używanego znaku Unicode, pomyślałem o tym, co może najlepiej reprezentować to wyzwanie, i przyszło mi do głowy, że Link i Zelda (lub, jeśli chcesz, Legenda o Zelda ) daje LZ , więc małe litery ʫ (U + 02AB, ʟᴀᴛɪɴ sᴍᴀʟʟ ʟᴇᴛᴛᴇʀ ʟᴢ ᴅɪɢʀᴀᴘʜ) wydają się odpowiednie.

Wyjaśnienie

Jak wyjaśniono w artykule esolangs, program Funciton odbiera dane wejściowe zakodowane jako coś, co nazwałbym „UTF-21”, ale jako pojedynczą ogromną liczbę całkowitą. Gdybym chciał użyć tego numeru jako klucza do mapy skrótów (słownik, tablica asocjacyjna), potrzebowałbym funkcji skrótu, która spełnia dwa kryteria: jedno, jest wystarczająco proste do zaimplementowania w Funciton i dwa, wszystkie 13 z oczekiwanych ciągi wejściowe dają inną wartość skrótu. Najprostsza funkcja skrótu, o której mogłem myśleć, dotyczyła input % mpewnej wartości m. Dlatego próbowałem m= 13, 14, 15 itd., Aż dotarłem do najmniejszej liczby całkowitej, dla której wszystkie wartości skrótu są unikalne. Okazuje się, że ta liczba to 25.

Wartości skrótu to:

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

Kodujemy każdą piosenkę, tak aby jeden bit reprezentował obecność lub brak nuty. Na przykład Kołysanka Zelda byłaby kodowana w następujący sposób:

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

z wyjątkiem tego, że bity są w odwrotnej kolejności; lewa górna komórka jest najmniej znacząca. Oznacza to, że każda piosenka ma 40 bitów.

W ten sposób tworzymy (umiarkowanie rzadką) tabelę skrótów, biorąc 40 × 25 = 1000-bitów i umieszczając wzór bitowy dla każdego utworu we właściwym miejscu zgodnie z jego wartością skrótu. Monstrualną liczbą w programie jest właśnie ta tabela skrótów.

Oto, co oznacza każda z pozostałych liczb:

• 45= 0x2DJest Unicode -.
• 1257283645609482190214660190: To jest ciąg znaków ^<>VAw UTF-21. Z perspektywy czasu mogłem użyć tutaj 7 bitów na znak, dzięki czemu liczba ta jest krótsza, ale UTF-21 jest tak głęboko tradycyjny w Funciton, że po prostu nie przyszło mi to do głowy.
• 2097151= 0x1FFFFF= (1 << 21) - 1. Służy do uzyskania pierwszego znaku z powyższego ciągu.
• 20971565: To jest ciąg -\n, który jest dołączany na końcu każdej linii.
  • Może się wydawać dziwne, że ta liczba i poprzedni wyglądają tak podobnie, ale jeśli się nad tym zastanowić, to dlatego, że używamy dziesiętnych, a Unicode \nma wartość 10. Ta ostatnia liczba to (10 << 21) + 45.

Program działa teraz w następujący sposób:

• Program główny wywołuje ʫ3 następujące parametry:
  • B : Tabela skrótów przesunięta w prawo o 40 bitów razy wartość skrótu wejścia. Piosenka, którą chcemy wydać, zawiera teraz 40 najmniej znaczących bitów.
  • c : ciąg ^<>VA.
  • Odp . : Liczba 8.
• W każdej iteracji ʫ,
  • jeśli c nie jest puste,
    • jeśli nie jest zero, spojrzenie na dolnym kawałku B . Wyjście , a następnie kolejne, jeśli w przeciwnym razie jest to zero lub pierwszy znak c . Przesuń w prawo B o jeden, aby usunąć jeden bit i zmniejszyć a .--
    • jeśli a wynosi zero, wyjdź -\n, a następnie odetnij pierwszy znak od c i rozpocznij kolejną pętlę z a = 8.
  • jeśli c jest puste, to skończymy.

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

Siatka jest generowana z myślnikami; następnie zindeksowano i zastąpiono notatkami.

Perl 5, 125 ( 320 260 250 bajtów -6x7% piosenki bonusowe -8% piosenka strach na wróble)

Tak, wreszcie okazja do eksperymentowania z tą składnią skrótu 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 bajtów - 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

Licząc shebang jako 2, dane wejściowe są pobierane ze standardowego wejścia.

Przykładowe użycie

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

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 wykonuje pracę.

Myślałem, że mogę pokonać Pythona za pomocą tych kodowań (zajęło mi to dużo czasu ._.), Ale nie. Tak naprawdę nie oszczędzają dużo bajtów. Jakieś sugestie?

Tak, to minus przed kodowaniem dla "ros". Dzieje się tak, ponieważ jego „arkusz” kończy się znakiem, który oznacza 0w mojej bazie 5, ponieważ ta negatywna sztuczka nie zadziałałaby dla „łatwych piosenek” zakodowanych przez podwojenie tego, co jest zakodowane s. Chyba że użyjesz quotmoże, ale wtedy nie poradzisz sobie p (-1)specjalnie, ponieważ quot (-5) = 0negatywność zniknie. Cokolwiek.

PHP: 130 bajtów (260 270 279 bajtów - 6 × 7% - 8%)

Dzięki Ismael Miguel i Blackhole za kilka świetnych pomysłów, aby zaoszczędzić więcej bajtów!

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

Po print"-tym następuje dosłowne wstawienie znaku powrotu karetki. Może to oznaczać dwa bajty w systemie Windows.

Wszystkie utwory bonusowe, w tym utwór Stracha na Wróble, są włączone.

Każda piosenka jest reprezentowana przez siedem bajtów kodu. Podoba mi się nowa punktacja, ponieważ przy starej punktacji zdobyłbym tylko jeden skromny punkt bonusowy!

Ostatnie zmiany powodują, że PHP generuje wiele ostrzeżeń, więc aby zachować ład i porządek, są one przekazywane /dev/null.

Zapisz jako zelda.phpi uruchom w wierszu poleceń:

$ 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 bajtów - 50%)

Ogoliłem kilka bajtów z bieżącego lidera Pythona, wykonując metodę drukowania zgodnie z rzeczywistym użyciem zamiast metody zastępowania.

Wypróbuj 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)

Biegać:

> python3 loz.py
bof [return]

Wynik:

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

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

Gra w golfa obejmuje:

usunięcie spacji między grupami liter w magicznym ciągu (i zmiana mianownika na końcu linii do /4.) Usunięcie niektórych innych niepotrzebnych białych znaków.

konwersja sekwencji ucieczki na pojedyncze znaki (wymiana stosów ich nie wyświetli, więc umieściłem ?jako symbol zastępczy)

redefinicja gjako pojedynczego ciągu zawierającego pięć ciągów -po 17, po których następują znaki nowej linii, zamiast tablicy pięciu ciągów po 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 (nie golf)

Kod wejściowy jest zredukowany do 2 liter. Jeśli zaczyna się od s, to sjest usuwane, jeśli zaczyna się na literę później s(dotyczy tylko zelostatniej litery, a jeśli zaczyna się na literę przed susunięciem środkowej litery).

Magiczny ciąg znaków (który w wersji bez golfa zawiera spacje dla przejrzystości) zawiera dwuliterowe kody, po których następują dane muzyczne. Jest przeszukiwany za pomocą operatora dopasowania, =~który zwraca pozycję w ciągu.

Jest dokładnie jedna piosenka, każda z 5, 7 i 8 nutami (plus scs, która ma również 8 nut.) Te, wraz z jedną dowolną 6-nutową piosenką, rossą pakowane na początku magicznego ciągu, dzięki czemu wartość npodana przez Pozycja struny może być wykorzystana do obliczenia liczby nut do zagrania. csjest wciśnięty wcześniej bf, a po obcięciu, gdy liczba njest zaokrąglana w dół, po prostu uzyskujemy prawidłowe obliczenia dla obu. Po czwartym klastrze wszystkie utwory mają 6 nut, więc jeśli njest duża, liczba nut jest zmniejszana do domyślnej wartości 6.

Tablica -jest ustawiony na wyjściu i uwagi są podstawione w jednej po drugiej. Wymagane dane muzyczne są pobierane ze zmiennej, $'która zawiera część oryginalnego magicznego ciągu po prawej stronie dopasowania. W ten sposób nieistotne dane są ignorowane.

Nuty są zakodowane po 3 w magicznym ciągu, zaraz po odpowiednim 2-literowym kodzie piosenki. Są one wyodrębniane z podziałem przez, 5**(i%3)a postać w gjest odpowiednio aktualizowana. Na końcu programu gjest drukowany.

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 bajtów -50% (283 bajtów)

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

Przechowuje każdą nutę jako bajt, ponieważ każda linia ma 8 nut. Przywołuje reprezentację binarną, a następnie zastępuje odpowiednimi znakami.

Lua, 249 bajtów - 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

Całkiem proste, po prostu odczytuje utwory zakodowane jako liczby podstawowe 6.