Như chúng ta đã biết, loạt Zelda là một trong những loạt trò chơi hay nhất từng được thực hiện. Để vinh danh điều đó, chúng ta hãy chơi một số bài hát trên ocarina.

Thử thách:

Viết một chương trình, cho một bài hát, đưa ra điểm số cho thiết bị xuất chuẩn cho bài hát cụ thể đó.

Đầu vào:

Bài hát mà bạn sẽ phải xuất ra số điểm sẽ được đưa ra bởi sự kết hợp ba ký tự duy nhất như được thấy dưới đây:

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

Bài hát thưởng, -7% mỗi bài:

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

Phần thưởng bài hát 2, -8%:

scs - Scarecrow's song 

Như chúng ta đã biết, bài hát của Bù nhìn là bài hát bạn tự sáng tác. Bài hát này cần phải có tám nốt nhạc. Xuất ra một số điểm bạn tự sáng tác khác với tất cả các điểm số khác.

Nếu bạn quyết định bao gồm tất cả các bài hát, nó sẽ có tổng tiền thưởng tới -50% cho điểm byte của bạn.

Đầu ra:

Các ghi chú trong đầu ra được ký hiệu bằng các ký tự sau:

^
<
>
V
A

Xuất một số điểm theo định dạng sau:

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

Chỉ có một lưu ý cho mỗi cột được cho phép. Để đơn giản, tôi đã thêm một hàng khác vào bốn hàng ban đầu.

Mỗi ghi chú tương ứng với một hàng khác nhau:

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

Đầu ra sẽ được ghi vào thiết bị xuất chuẩn. Trailing newlines được cho phép.

Ví dụ:

Đầu vào (Bài hát ru của Zelda):

zel

Đầu ra:

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

Đầu vào (Bolero of Fire):

bof

Đầu ra:

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

Lưu ý bảng cheat:

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

Vì chúng tôi chơi golf mã ocarina , chương trình ngắn nhất tính bằng byte sẽ thắng!

Tài liệu tham khảo bài hát:

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

Nó chứa các ký tự không thể in được, vì vậy đây là một xxdhexdump có thể đảo ngược :

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

Bạn cũng có thể thử nó trực tuyến .

Giải trình

Tôi lưu trữ các bài hát theo số cơ sở 6, được mã hóa lại thành cơ sở 1391423 và sau đó cơ sở 256 để tiết kiệm không gian. Tôi đã phải chọn cơ sở 6 vì một số bài hát bắt đầu ^và các số không thực sự bắt đầu bằng 0 sau khi giải mã.

  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

Chức năng , 4322 - 50% = 2161

Không thực sự cố gắng để chơi golf ở đây. Đi nhiều hơn cho góc đẹp. Tôi nghĩ rằng chương trình chính trông thực sự gọn gàng, một hộp hình chữ nhật hoàn hảo nằm bên phải.

Như mọi khi, bạn có thể có được kết xuất tốt hơn bằng cách thực hiện $('pre').css('line-height',1)trong bảng điều khiển trình duyệt của mình.

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

Tiếp tục truyền thống đặt tên hàm Funciton bao gồm một ký tự Unicode duy nhất, lạ, hiếm khi được sử dụng, tôi nghĩ về những gì có thể thể hiện tốt nhất cho thách thức này và tôi nhận ra rằng Link và Zelda (hoặc, nếu bạn muốn, Legend of Zelda ) cung cấp cho bạn LZ , do đó, sơ đồ chữ thường (U + 02AB, ʟᴀᴛɪɴ sᴍᴀʟʟ ʟᴇᴛᴛᴇʀ) có vẻ phù hợp.

Giải trình

Như đã giải thích trong bài viết của esolang, chương trình Funciton nhận được đầu vào được mã hóa như những gì tôi sẽ gọi là UT UTF-21, nhưng là một số nguyên đơn lẻ. Nếu tôi muốn sử dụng số này làm khóa cho hàm băm (từ điển, mảng kết hợp), tôi cần một hàm băm thỏa mãn hai tiêu chí: một, đủ đơn giản để thực hiện trong Funciton và hai, tất cả trong số 13 dự kiến chuỗi đầu vào cho một giá trị băm khác nhau. Hàm băm đơn giản nhất tôi có thể nghĩ là input % mcho một số giá trị m. Do đó, tôi đã thử m= 13, 14, 15, v.v. cho đến khi tôi nhận được số nguyên nhỏ nhất mà tất cả các giá trị băm là duy nhất. Hóa ra con số này là 25.

Các giá trị băm là:

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

Chúng tôi mã hóa mỗi bài hát bằng cách có một bit đại diện cho sự hiện diện hoặc vắng mặt của một ghi chú. Ví dụ, bài hát ru của Zelda sẽ được mã hóa như sau:

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

ngoại trừ các bit theo thứ tự ngược lại; ô trên cùng bên trái là trong bit ít quan trọng nhất. Điều này có nghĩa là mỗi bài hát dài 40 bit.

Do đó, chúng tôi tạo bảng băm (vừa phải thưa thớt) bằng cách lấy số 40 × 25 = 1000 bit và đặt mẫu bit cho mỗi bài hát vào đúng vị trí theo giá trị băm của nó. Số quái vật trong chương trình chính xác là bảng băm này.

Đây là ý nghĩa của mỗi số còn lại:

• 45= 0x2Dlà Unicode cho -.
• 1257283645609482190214660190: Đây là chuỗi ^<>VAtrong UTF-21. Nhìn chung, tôi có thể đã sử dụng 7 bit cho mỗi ký tự ở đây, làm cho số lượng ngắn hơn, nhưng UTF-21 là truyền thống sâu sắc trong Funciton đến nỗi nó đơn giản không xảy ra với tôi.
• 2097151= 0x1FFFFF= (1 << 21) - 1. Được sử dụng để lấy ký tự đầu tiên từ chuỗi trên.
• 20971565: Đây là chuỗi -\n, được nối vào cuối mỗi dòng.
  • Có vẻ như tò mò rằng con số này và số trước trông rất giống nhau, nhưng nếu bạn nghĩ về nó, thì đó là vì chúng tôi đang sử dụng số thập phân và Unicode cho \nsố đó là 10. Số cuối cùng đó là (10 << 21) + 45.

Chương trình hiện đang tiến hành như sau:

• Chương trình chính gọi ʫvới 3 tham số sau:
  • B : Bảng băm, dịch chuyển sang phải 40 bit nhân với giá trị băm của đầu vào. Bài hát chúng tôi muốn xuất bây giờ nằm ​​trong 40 bit có ý nghĩa nhỏ nhất.
  • c : Chuỗi ^<>VA.
  • a : Số 8.
• Trong mỗi lần lặp lại của ʫ,
  • nếu c không trống,
    • nếu một không phải là zero, nhìn vào các bit dưới cùng của B . Đầu ra -, tiếp theo là cái khác -nếu nó bằng 0 hoặc ký tự đầu tiên của c nếu không. Chuyển sang phải B một để loại bỏ một bit và giảm dần a .
    • nếu a bằng 0, xuất ra -\n, sau đó cắt ký tự đầu tiên từ c và bắt đầu một vòng lặp khác với a = 8.
  • nếu c trống, chúng ta đã xong.

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)

Lưới được tạo ra với dấu gạch ngang; sau đó được lập chỉ mục và thay thế bằng ghi chú.

Perl 5, 125 ( 320 260 250 Byte -6x7% bài hát thưởng -8% bài hát bù nhìn)

Yay, cuối cùng là một cơ hội để thử nghiệm cú pháp băm 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)

Kiểm tra

$ 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

Đếm shebang là 2, đầu vào được lấy từ stdin.

Sử dụng mẫu

$ 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 Làm công việc.

Nghĩ rằng tôi có thể đánh bại Python bằng cách sử dụng các bảng mã này (khiến tôi mất nhiều thời gian ._.), Nhưng không. Họ chưa thực sự tiết kiệm được nhiều byte. Bất kỳ đề xuất?

Vâng, đó là một điểm trừ trước mã hóa cho "ros". Đó là vì 'tờ' của nó kết thúc bằng ký tự có nghĩa là 0trong cơ sở 5 của tôi, bởi vì thủ thuật phủ định này sẽ không hoạt động đối với 'các bài hát dễ dàng' được mã hóa bằng cách nhân đôi những gì được mã hóa s. Trừ khi bạn sử dụng quotcó thể, nhưng sau đó bạn không thể xử lý p (-1)đặc biệt, vì quot (-5) = 0vậy, sự tiêu cực sẽ biến mất. Bất cứ điều gì.

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

Cảm ơn Ismael Miguel và Blackhole cho một số ý tưởng tuyệt vời để tiết kiệm nhiều byte hơn!

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

Sau đó print"-, đây là một nghĩa đen của việc trả lại xe ngựa. Nó có thể dịch sang hai byte trong Windows.

Tất cả các bài hát thưởng bao gồm bài hát của Bù nhìn được bao gồm.

Mỗi bài hát được thể hiện bằng bảy byte mã. Tôi thích cách tính điểm mới bởi vì với điểm số cũ, tôi sẽ chỉ kiếm được một điểm thưởng ít ỏi!

Các chỉnh sửa gần đây làm cho PHP tạo ra rất nhiều cảnh báo, vì vậy để giữ cho mọi thứ tốt đẹp và gọn gàng, chúng được chuyển hướng sang /dev/null.

Lưu dưới dạng zelda.phpvà chạy trên dòng lệnh:

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

Đã cạo một vài byte khỏi nhà lãnh đạo Python hiện tại trong khi thực hiện phương thức in khi bạn đi thay vì phương thức thay thế.

Thử trực tuyến

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)

Chạy:

> python3 loz.py
bof [return]

Đầu ra:

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

Ruby, rev 1, 192 - 50% = 96

Chơi gôn bao gồm:

xóa khoảng trắng giữa các nhóm chữ cái trong chuỗi ma thuật (và sửa đổi mẫu số ở cuối dòng thành /4.) Xóa một số khoảng trắng không cần thiết khác.

chuyển đổi các chuỗi thoát thành các ký tự đơn (trao đổi ngăn xếp sẽ không hiển thị chúng, vì vậy tôi đã đặt ?như một trình giữ chỗ)

xác định lại gdưới dạng một chuỗi chứa năm lần chạy 17 -theo sau là dòng mới, thay vì một chuỗi gồm năm chuỗi 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 (chưa được chỉnh sửa)

Mã đầu vào được giảm xuống còn 2 chữ cái. Nếu nó bắt đầu bằng một s, thì ssẽ bị xóa, nếu nó bắt đầu bằng một chữ cái sau s(chỉ áp dụng cho zelchữ cái cuối cùng bị xóa và nếu nó bắt đầu bằng một chữ cái trước khi schữ cái giữa bị xóa.

Chuỗi ma thuật (trong phiên bản không có chứa khoảng trống cho rõ ràng) chứa mã 2 chữ cái theo sau là dữ liệu âm nhạc. Nó được tìm kiếm bằng cách sử dụng toán tử khớp =~trả về vị trí trong chuỗi.

Có chính xác một bài hát mỗi bài gồm 5, 7 và 8 nốt (cộng với sc cũng có 8 nốt.) Những bài này, cùng với một bài hát 6 nốt tùy ý rosđược gói ở đầu chuỗi ma thuật sao cho giá trị nđược đưa ra bởi vị trí trong chuỗi có thể được sử dụng để tính số lượng ghi chú để chơi. csđược nén trước bfvà với việc cắt bớt khi số trong nđược làm tròn xuống, chúng ta chỉ cần bỏ đi với phép tính đúng cho cả hai. Sau cụm thứ tư, tất cả các bài hát đều có 6 nốt, vì vậy nếu nlớn, số lượng nốt được giảm xuống mặc định là 6.

Một mảng -được thiết lập cho đầu ra và các ghi chú được thay thế từng cái một. Dữ liệu âm nhạc cần thiết được trích xuất từ ​​biến $'chứa một phần của chuỗi ma thuật gốc ở bên phải của trận đấu. Theo cách này, dữ liệu không liên quan được bỏ qua.

Các ghi chú được mã hóa 3 lần vào chuỗi ma thuật, ngay sau mã bài hát 2 chữ cái có liên quan. Chúng được trích xuất với phép chia 5**(i%3)và một ký tự trong gđược cập nhật tương ứng. Vào cuối chương trình gđược in.

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

Lưu trữ mỗi ghi chú dưới dạng một byte vì mỗi dòng dài 8 ghi chú. Nhớ lại biểu diễn nhị phân và sau đó thay thế bằng các ký tự bên phải.

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

Khá đơn giản, chỉ cần đọc lại các bài hát được mã hóa dưới dạng số cơ sở 6.