Wie wir alle wissen, ist die Zelda-Serie eine der besten, die jemals gemacht wurden. Lassen Sie uns zu Ehren ein paar Lieder auf der Okarina spielen.

Herausforderung:

Schreiben Sie ein Programm, das bei gegebenem Song die Partitur für diesen bestimmten Song als Standard ausgibt.

Eingang:

Das Lied, dessen Punktzahl Sie ausgeben müssen, wird durch eine eindeutige Kombination von drei Zeichen angegeben, wie unten dargestellt:

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 Songs, jeweils -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

Bonussong 2, -8%:

scs - Scarecrow's song 

Wie wir alle wissen, ist das Lied der Vogelscheuche ein Lied, das Sie selbst komponieren. Dieses Lied muss acht Noten haben. Geben Sie eine Partitur aus, die Sie selbst zusammengestellt haben und die sich von allen anderen Partituren unterscheidet.

Wenn Sie sich dazu entschließen, alle Songs einzuschließen, erhalten Sie einen Bonus von -50% auf Ihre Byte-Punktzahl.

Ausgabe:

Die Anmerkungen in der Ausgabe werden durch die folgenden Zeichen symbolisiert:

^
<
>
V
A

Geben Sie eine Partitur im folgenden Format aus:

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

Es ist nur eine Note pro Spalte zulässig. Der Einfachheit halber habe ich eine weitere Zeile zu den ursprünglichen vier Zeilen hinzugefügt.

Jede Note entspricht einer anderen Zeile:

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

Die Ausgabe wird auf stdout geschrieben. Nachgestellte Zeilenumbrüche sind zulässig.

Beispiele:

Input (Zeldas Wiegenlied):

zel

Ausgabe:

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

Eingabe (Bolero of Fire):

bof

Ausgabe:

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

Hinweis Spickzettel:

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

Da wir den Ocarina Code Golf spielen, gewinnt das kürzeste Programm in Bytes!

Song Referenzen:

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

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

Pyth, 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

Es enthält nicht druckbare Zeichen, daher hier ein umkehrbarer xxdHexdump:

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

Sie können es auch online ausprobieren .

Erläuterung

Ich speichere die Songs in Basis-6-Zahlen, umkodiert in Basis 1391423 und dann Basis 256, um Platz zu sparen. Ich musste Base 6 wählen, da einige der Songs mit beginnen ^und Zahlen nach dem Decodieren nicht wirklich mit einer 0 beginnen können.

  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

Funktion , 4322 - 50% = 2161

Ich versuche hier nicht wirklich Golf zu spielen. Mehr auf den Beauty-Aspekt setzen. Ich denke, das Hauptprogramm sieht wirklich gut aus, eine perfekte rechteckige Box, die rechts versteckt ist.

Wie immer können Sie ein besseres Rendering erzielen, indem Sie es $('pre').css('line-height',1)in Ihrer Browserkonsole ausführen .

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

Fortsetzung in der Tradition Funciton Funktionen Namen geben , bestehend aus einem einzigen, merkwürdig, selten verwendeten Unicode - Zeichen, dachte ich darüber nach, was am besten diese Herausforderung darstellen könnte, und es fiel mich ein, dass Link - und Zelda (oder, wenn Sie wollen, Legend of Zelda ) geben Sie LZ , so dass der Kleinbuchstabe ʫ (U + 02AB, ʟᴀᴛɪɴ sʟᴀᴛɪɴ ʟᴇᴛᴛᴇʀ ʟᴇᴛᴛᴇʀ ʟᴢ) angemessen erscheint.

Erläuterung

Wie im esolangs-Artikel erläutert, empfängt das Funciton-Programm die Eingabe in der Codierung "UTF-21", jedoch als einzelne humongous Ganzzahl. Wenn ich diese Zahl als Schlüssel für eine Hashmap (Wörterbuch, assoziatives Array) verwenden wollte, bräuchte ich eine Hash-Funktion, die zwei Kriterien erfüllt: eine, die in Funciton einfach zu implementieren ist, und zwei, die alle 13 erwarteten Eingabezeichenfolgen geben einen anderen Hash-Wert. Die einfachste Hash-Funktion, die ich mir vorstellen konnte, war input % mfür einen bestimmten Wert von m. Daher habe ich versucht m= 13, 14, 15 usw., bis ich zu der kleinsten Ganzzahl kam, für die alle Hash-Werte eindeutig sind. Es stellte sich heraus, dass diese Zahl 25 ist.

Die Hashwerte sind:

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

Wir kodieren jedes Lied, indem wir ein Bit das Vorhandensein oder Fehlen einer Note darstellen lassen. Zum Beispiel würde Zeldas Wiegenlied folgendermaßen codiert werden:

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

außer dass die Bits in der entgegengesetzten Reihenfolge sind; Die obere linke Zelle befindet sich im niedrigstwertigen Bit. Dies bedeutet, dass jedes Lied 40 Bits lang ist.

Wir erstellen daher eine (mäßig spärliche) Hash-Tabelle, indem wir eine 40 × 25 = 1000-Bit-Zahl nehmen und das Bitmuster für jedes Lied entsprechend seinem Hash-Wert an der richtigen Stelle platzieren. Die monströse Zahl im Programm ist genau diese Hash-Tabelle.

Die verbleibenden Zahlen bedeuten jeweils Folgendes:

• 45= 0x2Dist der Unicode für -.
• 1257283645609482190214660190: Dies ist die Zeichenfolge ^<>VAin UTF-21. Im Nachhinein hätte ich hier 7 Bits pro Zeichen verwenden können, was die Zahl kürzer machte, aber UTF-21 ist in Funciton so traditionell, dass es mir einfach nicht in den Sinn kam.
• 2097151= 0x1FFFFF= (1 << 21) - 1. Wird verwendet, um das erste Zeichen aus der obigen Zeichenfolge abzurufen.
• 20971565: Dies ist die Zeichenfolge -\n, die an das Ende jeder Zeile angehängt wird.
  • Es mag merkwürdig erscheinen, dass diese Zahl und die vorherige Zahl so ähnlich aussehen, aber wenn Sie darüber nachdenken, liegt das daran, dass wir eine Dezimalzahl verwenden und der Unicode- \nWert zufällig 10 ist. Diese letzte Zahl ist (10 << 21) + 45.

Das Programm läuft nun wie folgt ab:

• Das Hauptprogramm ruft ʫmit den folgenden 3 Parametern auf:
  • B : Die Hash-Tabelle, um das 40-Bit-fache des Hash-Werts der Eingabe nach rechts verschoben. Das Lied, das wir ausgeben möchten, befindet sich jetzt in den 40 niedrigstwertigen Bits.
  • c : Die Zeichenfolge ^<>VA.
  • a : Die Nummer 8.
• In jeder Iteration von ʫ,
  • wenn c nicht leer ist,
    • Wenn a nicht Null ist, schauen Sie sich das untere Bit von B an . Ausgabe -, gefolgt von einem anderen, -wenn es null ist, oder dem ersten Zeichen von c, andernfalls. Rechtsschiebe B durch eine ein Bit zu entfernen und dekrementieren a .
    • Wenn a Null ist, wird ausgegeben -\n, das erste Zeichen von c abgeschnitten und eine weitere Schleife mit a = 8 gestartet .
  • Wenn c leer ist, sind wir fertig.

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)

Das Raster wird mit Bindestrichen generiert. dann indiziert und durch Notizen ersetzt.

Perl 5, 125 ( 320 260 250 Bytes -6x7% Bonuslieder -8% Vogelscheuchenlied)

Yay, endlich eine Gelegenheit, mit dieser perlischen Hash-Syntax zu experimentieren.

$_=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)

Prüfung

$ 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

Zählt man den Shebang als 2, wird die Eingabe von stdin übernommen.

Beispielnutzung

$ 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 macht den Job.

Ich dachte, ich könnte Python mit diesen Kodierungen schlagen (ich habe lange gebraucht.), Aber nein. Sie sparen noch nicht wirklich viele Bytes. Irgendwelche Vorschläge?

Ja, das ist ein Minus vor der Kodierung für "ros". Das liegt daran, dass sein "Sheet" mit dem Zeichen endet, das 0in meiner Basis 5 bedeutet, da dieser negative Trick für die "einfachen Songs", die durch das Verdoppeln des Codierten codiert wurden, nicht funktioniert s. Es sei denn, Sie verwenden quotmöglicherweise, aber dann können Sie nicht p (-1)speziell behandeln, da quot (-5) = 0, damit die Negativität verschwinden würde. Wie auch immer.

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

Vielen Dank an Ismael Miguel und Blackhole für einige großartige Ideen, um mehr Bytes zu sparen!

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

Nach dem print"-ist dies eine wörtliche Einfügung eines Wagenrücklaufs. Es kann in Windows in zwei Bytes übersetzt werden.

Alle Bonussongs, einschließlich des Songs der Vogelscheuche, sind enthalten.

Jedes Lied wird in sieben Byte Code dargestellt. Ich mag die neue Wertung, weil ich mit der alten Wertung insgesamt nur einen mageren Bonuspunkt gewonnen hätte!

Die jüngsten Änderungen lassen PHP eine Menge Warnungen generieren. Um die Dinge schön und aufgeräumt zu halten, werden diese an umgeleitet /dev/null.

Speichern unter zelda.phpund in der Befehlszeile ausführen:

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

Rasiert ein paar Bytes vor dem aktuellen Python-Anführer, während die Print-as-you-go-Methode und nicht die Ersetzungsmethode ausgeführt wird.

Versuchen Sie es 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)

Lauf:

> python3 loz.py
bof [return]

Ausgabe:

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

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

Golfen beinhaltet:

Entfernen von Leerzeichen zwischen Buchstabengruppen in der magischen Zeichenfolge (und Überarbeitung des Nenners am Ende der Zeile bis /4). Entfernen von anderen unnötigen Leerzeichen.

Umwandlung der Escape-Sequenzen in einzelne Zeichen (Stapelaustausch zeigt sie nicht an, also habe ich sie ?als Platzhalter gesetzt)

Neudefinition von gals eine einzelne Zeichenfolge mit fünf -Folgen von 17, gefolgt von Zeilenumbrüchen, anstelle eines Arrays von fünf Folgen von 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 (ungolfed)

Der Eingabecode ist auf 2 Buchstaben reduziert. Beginnt es mit einem s, wird das sgelöscht, beginnt es mit einem Buchstaben danach s(gilt nur für zelden letzten Buchstaben, wird gelöscht, und beginnt es mit einem Buchstaben, bevor sder mittlere Buchstabe gelöscht wird.

Die magische Zeichenfolge (die in der ungolfed-Version aus Gründen der Übersichtlichkeit Leerzeichen enthält) enthält die 2-Buchstaben-Codes, gefolgt von den Musikdaten. Es wird mit dem Übereinstimmungsoperator gesucht, der =~die Position in der Zeichenfolge zurückgibt.

Es gibt genau ein Lied mit 5, 7 und 8 Noten (plus SCS mit 8 Noten). Diese werden zusammen mit einem beliebigen Lied mit 6 Noten rosam Anfang der magischen Zeichenfolge gebündelt, so dass der Wert von ngegeben ist Die Position in der Saite kann verwendet werden, um die Anzahl der zu spielenden Noten zu berechnen. cswird vorher eingedrückt bf, und mit dem Abschneiden, wenn die Zahl nabgerundet wird, kommen wir einfach mit der korrekten Berechnung für beide davon. Nach dem vierten Cluster haben alle Songs 6 Noten. Wenn nalso die Anzahl der Noten groß ist, wird sie auf den Standardwert von 6 reduziert.

Ein Array von -wird für die Ausgabe eingerichtet und die Noten werden einzeln ersetzt. Die erforderlichen Musikdaten werden aus der Variablen extrahiert, $'die den Teil der ursprünglichen magischen Zeichenfolge rechts von der Übereinstimmung enthält. Auf diese Weise werden irrelevante Daten ignoriert.

Die Noten werden direkt nach dem entsprechenden 2-Buchstaben-Song-Code jeweils 3 Mal in die magische Zeichenfolge codiert. Sie werden durch Division durch extrahiert 5**(i%3)und ein Zeichen in gwird entsprechend aktualisiert. Am Ende des Programms gwird gedruckt.

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

Speichert jede Note als Byte, da jede Zeile 8 Noten lang ist. Ruft die Binärdarstellung auf und wird dann durch die richtigen Zeichen ersetzt.

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

Ziemlich einfach, liest nur Songs zurück, die als Basis-6-Zahlen codiert sind.