让我们演奏陶笛

42

众所周知，《塞尔达传说》系列是有史以来最好的游戏系列之一。为此，让我们在ocarina上播放一些歌曲。

挑战：

编写一个程序，给定一首歌曲，将特定歌曲的乐谱输出到stdout。

输入：

您必须输出乐谱的歌曲将由唯一的三个字符组合给出，如下所示：

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

奖励歌曲，每首-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

奖励歌曲2，-8％：

scs - Scarecrow's song

众所周知，稻草人的歌曲是您自己创作的歌曲。这首歌需要有八个音符。输出您自己撰写的分数，该分数不同于所有其他分数。

如果您决定包括所有歌曲，则总计将为您的字节分数带来-50％的奖励。

输出：

输出中的注释由以下字符表示：

^
<
>
V
A

以以下格式输出分数：

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

每栏只允许一个注释。为了简单起见，我在原始的四行中添加了另一行。

每个注释对应于不同的行：

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

输出应写入标准输出。尾随换行符是允许的。

例子：

输入（塞尔达的摇篮曲）：

zel

输出：

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

输入（射击的Bolero）：

bof

输出：

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

注意备忘单：

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

因为我们打的是ocarina码高尔夫，所以最短的节目以字节为单位将获胜！

歌曲参考：

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

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

code-golf  ascii-art  music 
— sweerpotato
source
4
也许您应该使用％奖励，而不是字节奖励。将所有这些歌曲都编码为<7个字节几乎是不可能的，因此，目前没有任何奖金值得。您还应该提到稻草人的歌曲应该由8个实际音符组成。否则有人可能会打印一个空分数。除此之外，还不错的挑战！
— ETHproductions's
9
我能在脑海中听到这些歌曲并读到这个问题，这使我想知道自己在做什么。我的意思是，我可以在玩OoT的时候在工作……
— MikeTheLiar 2015年
11
我希望这不会使现有的答案无效，但请注意，在原始的《塞尔达传说》中稻草人的歌曲必须由两个不同的音符组成，因此，例如AAAAAAAA 不会是有效的稻草人的歌曲。
— 2015年
4
我认为小写v看起来会更好。
— mbomb007
3
我真的等着看有人能用vellato或fugue解决这个问题，并在ocarina上播放
— 吗

Answers:

8

Pyth，56.5（113字节-6×7％-8％）

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

它包含不可打印的字符，因此这是一个可逆的xxd十六进制转储：

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

您也可以在线尝试。

说明

我将歌曲存储在以6为基数的数字中，然后重新编码为以1391423为基数，然后再以256为基数以节省空间。我必须选择以6为底，因为某些歌曲以开头^，并且解码后编号不能真正以0开头。

  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
— PurkkaKoodari
source
44

函数，4322 − 50％= 2161

并不是真的想在这里打高尔夫球。为美丽角度而努力。我认为主程序看起来非常整洁，右侧有一个完美的矩形框。

与往常一样，您可以通过$('pre').css('line-height',1)在浏览器控制台中执行来获得更好的渲染。

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

我继续给Funciton函数起一个由一个奇怪的，很少使用的Unicode字符组成的名称的传统，我想到了最能代表这一挑战的东西，我想到了Link和Zelda（或者，如果需要的话，Legend of Zelda）给您LZ，因此小写字母graph（U + 02AB，ʟᴀᴛɪɴsᴍᴀʟʟʟᴢᴅɪɢʀᴀᴘʜ）似乎合适。

说明

如esolangs文章中所述，Funciton程序接收输入编码为我称之为“ UTF-21”的输入，但编码为单个巨大整数。如果我想使用此数字作为哈希图（字典，关联数组）的键，则需要满足两个条件的哈希函数：一个足够简单，可以在Funciton中实现，另外两个则可以满足所有13个条件输入字符串提供不同的哈希值。我能想到的最简单的哈希函数是input % m的某个值m。因此，我尝试m= 13、14、15等，直到获得所有哈希值都是唯一的最小整数。原来这个数字是25。

哈希值是：

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

我们通过用一位代表音符的存在或不存在来编码每首歌曲。例如，Zelda的Lullaby编码如下：

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

除了这些位以相反的顺序；左上方的单元格位于最低有效位。这意味着每首歌曲都是40位长。

因此，我们通过获取40×25 = 1000位数字并根据其哈希值将每首歌曲的位模式放在正确的位置来创建（中等稀疏）哈希表。程序中的怪异数字就是这个哈希表。

以下是其余每个数字的含义：

  • 45= 0x2D是的Unicode -。
  • 1257283645609482190214660190：这是^<>VAUTF-21中的字符串。事后看来，我本可以在每个字符上使用7位，从而使数字更短，但是UTF-21在Funciton中非常传统，以至于我完全没有想到。
  • 2097151= 0x1FFFFF=（1 << 21）− 1.用于从上述字符串中获取第一个字符。
  • 20971565：这是字符串-\n，它附加在每行的末尾。
    • 看起来这个数字和前一个数字看起来如此相似似乎有些奇怪，但是如果您考虑一下，那是因为我们使用的是十进制，而Unicode \n恰好是10。最后一个数字是（10 << 21）+ 45。

该程序现在按如下方式进行：

  • 主程序ʫ使用以下3个参数进行调用：
    • B：哈希表，右移40位乘以输入的哈希值。现在，我们要输出的歌曲的最低40位。
    • c：字符串^<>VA。
    • a：数字8。
  • 在的每次迭代中ʫ，
    • 如果c不为空，
      • 如果a不为零，则查看B的最低位。输出-，-如果为零则返回另一个，否则返回c的第一个字符。向右移B一位，将a减1。
      • 如果a为零，则输出-\n，然后从c中斩除第一个字符，并以a = 8 开始另一个循环。
    • 如果c为空，我们就完成了。
— Timwi
source
做得好，令人印象深刻！
— sweerpotato
6
<叽>那宕音乐平坦...投掷关闭monospacing ... </叽>
— 泰勒洛佩兹
1
@iAmMortos：同意。因此，我长时间避免使用♭字符，并说服自己可以按位而不是，然后按♯，然后按位。但是现在我用Deja Vu Sans Mono来编辑Funciton，它有♭。所以现在我们需要做的就是让StackExchange也切换到该字体以获取代码；-)
— Timwi
4
另外，您肯定必须承认，没有比♭和better更适合Unicode字符的减量和增量了。他们是完美的。
— Timwi
哈哈，全是。我对功能一无所知，但这完全合情合理！
— 泰勒·洛佩兹
11

Python 2，143.5（287字节-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)

网格是用破折号生成的。然后将其编入索引并替换为注释。

— Zach Gates
source
没花太多时间，但是您可以在声明中节省字节，方法j是用空格替换每个逗号split并不带任何参数调用
— Undergroundmonorail
我认为您不需要这样做，它仍然是您的算法，因此我认为您值得代表，但是无论如何，我还是设法摆脱了range。可悲的是，您不能仅将内部列表乘以5，因为它们都是相同的对象，而改变一个则改变了其他对象：/虽然我们击败了perl（现在）！
— FryAmTheEggman 2015年
通过执行"<^><^>"=>之类的操作，您是否不能消除6个字节（前六首歌曲中的每一个为1个字节）"<^>"*2？
— El'endia Starman
scs="<"*8 我不喜欢你的稻草人歌曲。
— Casey Kuball 2015年
当我尝试运行此命令时，它仅在第2行停止，并且从未完成。
— 科里·克莱恩
7

Perl 5中，125（320 260 250字节-6x7％的奖金歌曲-8％稻草人歌曲）

是的，终于有机会尝试使用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)

测试

$ perl -M5.010 ocarina.pl scs
---^---------^---
-<-------------<-
------->->-------
-----V-----V-----
-----------------
— 暴风雨
source
1
使用qw()语法而不是粗体的逗号（%h=qw(zel <^><^> sas >'V><' ...)以节省一些字节
— mob
1
@mob该建议不仅节省了“一些”字节。：） 谢谢！
— LukStorms
1
@L可以更简洁地写成@L=('-')x17。此外，主哈希可以保留为匿名@B={qw(zel <^><^> ... scs <^V>>V^<)}->{$_}=~/./g。
— primo 2015年
1
我知道，这些是避免稍微冗长的split函数的好技巧。剩下的十个字节被牺牲了。tumbs了
— LukStorms
5

Perl，75（150字节-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

将shebang计为2，输入来自stdin。

样品用法

$ 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-
— 原始
source
1
使用位移VEC功能吗？惊人。
— LukStorms
@LukStorms我希望它可以执行3位操作，而不是仅执行2次幂操作；）
— primo
4

Haskell，344-50％= 172字节

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 做这份工作。

以为我可以通过使用这些编码来击败Python（花了我很长时间._。），但没有。他们并没有真正节省很多字节。有什么建议么？

是的，这是的编码前面的减号"ros"。那是因为其“工作表” 0以我的base-5中的字符结尾，因为这种否定性技巧不适用于通过将编码的内容加倍来编码的“轻松的歌曲” s。除非您使用quot，否则就不能进行p (-1)特殊处理，因为quot (-5) = 0，所以负性会消失。随你。

— 雷夫·威勒茨
source
4

PHP：130个字节（260个270 279字节- 6×7％ - 8％）

感谢Ismael Miguel和Blackhole提出了一些节省更多字节的好主意！

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

在之后print"-，这是回车符的字面插入。在Windows中可能会转换为两个字节。

包括稻草人的歌曲在内的所有奖励歌曲都包括在内。

每首歌曲以七个字节的代码表示。我喜欢新的评分，因为如果使用旧的评分，我总体只会获得微薄的积分！

最近的修改使PHP生成了很多警告，因此为了使内容整洁，请改用/dev/null。

另存为zelda.php并在命令行上运行：

$ 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-                                                                                                                                   
-----------------
您是说“另存为main.php”吗？
— 扎克·盖茨
@ZachGates-感谢您对此进行了更改。
你不需要在()周围($i-$c)上echo($i-$c)?'--':'-'.$z[$c-0];。此外，您的字符串split也可以不使用'。并且'/^'.$argv[1].'/'可以写成"/^$argv[1]/"
— 伊斯梅尔·米格尔
1
谢谢！我认为CGSE允许将警告传递到/ dev / null来清理输出？
@Blackhole-谢谢！它与Perl 5提交捆绑在一起，做的还不错……
4

Python的3 - 138.5（292 280 277字节- 50％）

在执行“按需打印”方法而不是“替换”方法时，将当前的Python领导者削减了几个字节。

在线尝试

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)

跑：

> python3 loz.py
bof [return]

输出：

-----------------
-----------------
--------->--->---
-V---V-----V---V-
---A---A---------
— 泰勒·洛佩兹（Taylor Lopez）
source
您可以通过使用['--',c+'-'][s[x]==c]而不是有条件的方式节省一些字节
— Ruth Franklin
哦，打个招呼，谢谢！
— 泰勒·洛佩兹
3

红宝石，版本1，192-50％= 96

打高尔夫球包括：

删除魔术字符串中各组字母之间的空格（并将行尾的分母修订为/4。）删除一些其他不必要的空格。

转义序列转换为单个字符（堆栈交换不会显示它们，因此我已将其?用作占位符）

重新定义g为一个包含五个游程的17个字符串，-后跟换行符的单个字符串，而不是包含五个由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

红宝石，修订版0，223-50％= 111.5（无胶）

输入的代码减少为2个字母。如果以开头s，s则删除，如果以后面的字母开头s（仅适用于zel最后一个字母，并且s以中间的字母开头则删除）。

魔术字符串（在无高尔夫球版本中为清晰起见，包含空格）包含2个字母的代码，后跟音乐数据。使用匹配运算符搜索它，该运算符=~返回字符串中的位置。

恰好有各自的5首歌，7，和8个音符（+许旺其中也有8个音符。）这些，用一个任意6注乐曲一起ros在魔法字符串的开头，这样捆绑的值n由下式给出字符串中的位置可用于计算要弹奏的音符数。cs在之前被压缩，bf当数字n被舍入时，随着截断，我们只是对两者的正确计算有所了解。在第四个簇之后，所有歌曲都有6个音符，因此，如果n音符数量较大，则将其减小为默认值6。

-设置了一个数组用于输出，并且注释被一一替换。从变量$'中提取所需的音乐数据，该变量包含比赛右侧原始魔术字符串的一部分。这样，无关的数据将被忽略。

在相关的2字母歌曲代码之后，音符一次被编码3到魔术字符串中。通过除以提取它们，5**(i%3)并g相应更新一个字符。在程序的末尾g被打印。

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
— 水准河圣
source
2

Python 2，141.5字节-50％（283字节）

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

将每个音符存储为字节，因为每行长8个音符。调用二进制表示形式，然后替换为正确的字符。

— 蓝色
source
1

Lua，249字节-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

非常简单，只需读回编码为6进制数的歌曲即可。

— ip脚与莫妮卡站在一起
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.