Juguemos la ocarina

42

Como todos sabemos, la serie Zelda es una de las mejores series de juegos jamás hechas. En honor a eso, toquemos algunas canciones en la ocarina.

Reto:

Escriba un programa que, dada una canción, genere la partitura para stdout para esa canción en particular.

Entrada:

La canción de la que tendrá que emitir el puntaje será dada por una combinación única de tres caracteres como se ve a continuación:

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

Canciones extra, -7% cada una:

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

Bonus song 2, -8%:

scs - Scarecrow's song

Como todos sabemos, la canción del Espantapájaros es una canción que compones tú mismo. Esta canción necesita tener ocho notas. Produzca un puntaje que componga usted mismo que sea diferente de todos los otros puntajes.

Si decide incluir todas las canciones, totalizará un bono de -50% a su puntuación de bytes.

Salida:

Las notas en la salida están simbolizadas por los siguientes caracteres:

^
<
>
V
A

Salida de una puntuación en el siguiente formato:

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

Solo se permite una nota por columna. Por simplicidad, he agregado otra fila a las cuatro filas originales.

Cada nota corresponde a una fila diferente:

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

La salida se escribirá en stdout. Se permiten nuevas líneas al final.

Ejemplos:

Entrada (Canción de cuna de Zelda):

zel

Salida:

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

Entrada (Bolero de fuego):

bof

Salida:

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

Nota hoja de trucos:

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

Como jugamos al golf de código ocarina , ¡gana el programa más corto en bytes!

Referencias de canciones:

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 
— patata dulce
fuente
44
Quizás deberías usar una bonificación de% en lugar de una bonificación de bytes. Es prácticamente imposible codificar cualquiera de estas canciones en <7 bytes, por lo que ninguno de los bonos valdría la pena. También debe mencionar que la canción Scarecrow debe estar compuesta de 8 notas reales; de lo contrario, alguien podría imprimir una partitura vacía. Pero aparte de eso, ¡buen desafío!
— ETHproductions
99
El hecho de poder escuchar estas canciones en mi cabeza al leer esta pregunta me hace preguntarme qué estoy haciendo con mi vida. Quiero decir, estoy en el trabajo cuando podría estar jugando OoT ...
— MikeTheLiar
11
Espero que esto no invalide ninguna respuesta existente, pero tenga en cuenta que en la Zelda original, la canción del espantapájaros debe estar compuesta de dos notas diferentes , por lo que, por ejemplo, AAAAAAAA no sería una canción válida de espantapájaros.
— Jan
44
Creo que las minúsculas se vverían mejor.
— mbomb007
3
Realmente estoy esperando ver si alguien resuelve este problema en vellato o fuga y lo juega en ocarina
— user902383

Respuestas:

8

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

Contiene caracteres no imprimibles, así que aquí hay un xxdhexdump reversible :

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

También puedes probarlo en línea .

Explicación

Almaceno las canciones en números de base 6, vuelvo a codificar en base 1391423 y luego en base 256 para ahorrar espacio. Tuve que elegir la base 6 ya que algunas de las canciones comienzan con ^, y los números realmente no pueden comenzar con un 0 después de la decodificación.

  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
fuente
44

Funciton , 4322 - 50% = 2161

Realmente no estoy tratando de jugar golf aquí. Yendo más por el ángulo de belleza. Creo que el programa principal se ve muy bien, una caja rectangular perfecta escondida a la derecha.

Como siempre, puede obtener una mejor representación al ejecutar $('pre').css('line-height',1)en la consola de su navegador.

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

Continuando con la tradición de dar nombres a las funciones de Funciton que consisten en un solo personaje Unicode extraño, rara vez utilizado, pensé en lo que podría representar mejor este desafío, y se me ocurrió que Link y Zelda (o, si lo desea, Legend of Zelda ) le da LZ , por lo que el dígrafo en minúscula ʫ (U + 02AB, ʟᴀᴛɪɴ sᴍᴀʟʟ ʟᴇᴛᴛᴇʀ ʟᴢ ᴅɪɢʀᴀᴘʜ) parece apropiado.

Explicación

Como se explica en el artículo de esolangs, el programa Funciton recibe la entrada codificada como lo que yo llamaría "UTF-21", pero como un entero entero enorme. Si quisiera usar este número como clave para un hashmap (diccionario, matriz asociativa), necesitaría una función hash que satisfaga dos criterios: uno, es lo suficientemente simple de implementar en Funciton, y dos, los 13 esperados Las cadenas de entrada dan un valor hash diferente. La función hash más simple que se me ocurrió fue input % mpor algún valor m. Por lo tanto, intenté m= 13, 14, 15, etc. hasta que llegué al número entero más pequeño para el cual todos los valores hash son únicos. Resulta que este número es 25.

Los valores hash son:

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

Codificamos cada canción haciendo que un bit represente la presencia o ausencia de una nota. Por ejemplo, la canción de cuna de Zelda se codificaría de la siguiente manera:

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

excepto que los bits están en el orden opuesto; la celda superior izquierda está en el bit menos significativo. Esto significa que cada canción tiene 40 bits de longitud.

Por lo tanto, creamos una tabla hash (moderadamente escasa) tomando un número de 40 × 25 = 1000 bits y colocando el patrón de bits para cada canción en el lugar correcto de acuerdo con su valor hash. El número monstruoso en el programa es exactamente esta tabla hash.

Esto es lo que significa cada uno de los números restantes:

  • 45= 0x2Des el Unicode para -.
  • 1257283645609482190214660190: Esta es la cadena ^<>VAen UTF-21. En retrospectiva, podría haber usado 7 bits por personaje aquí, acortando el número, pero UTF-21 es tan tradicional en Funciton que simplemente no se me ocurrió.
  • 2097151= 0x1FFFFF= (1 << 21) - 1. Se utiliza para obtener el primer carácter de la cadena anterior.
  • 20971565: Esta es la cadena -\n, que se agrega al final de cada línea.
    • Puede parecer curioso que este número y el anterior se vean tan similares, pero si lo piensa, es porque estamos usando decimal y el Unicode para \nser 10. Es el último número (10 << 21) + 45.

El programa ahora procede de la siguiente manera:

  • El programa principal llama ʫcon los siguientes 3 parámetros:
    • B : La tabla hash, desplazada a la derecha 40 bits por el valor hash de la entrada. La canción que queremos generar ahora está en los 40 bits menos significativos.
    • c : la cadena ^<>VA.
    • a : El número 8.
  • En cada iteración de ʫ,
    • si c no está vacío,
      • si una no es cero, vistazo a la parte inferior de bits B . Salida -, seguido de otro -si es cero o el primer carácter de c de lo contrario. Desplazar a la derecha B por uno para eliminar un bit y disminuir a .
      • si a es cero, salida -\n, luego corta el primer carácter de c y comienza otro ciclo con a = 8.
    • si c está vacío, hemos terminado.
— Timwi
fuente
Bien hecho, eso es impresionante!
— sweerpotato
66
<grumble> Ese maldito piso musical ... deshaciéndose del monoespacio ... </grumble>
— Taylor Lopez
1
@iAmMortos: De acuerdo. Por esta razón, evité el carácter ♭ durante mucho tiempo y me convencí de que podía simplemente bitwise-not, luego ♯, bitbit-not. Pero ahora uso Deja Vu Sans Mono para editar Funciton y tiene ♭. Así que ahora todo lo que necesitamos es que StackExchange cambie a esa fuente para el código también ;-)
— Timwi
44
Además, seguramente debe admitir que no hay un mejor carácter Unicode para decremento e incremento que ♭ y ♯. No son más que perfecta .
— Timwi
Jaja, totalmente. No sé nada sobre la función, ¡pero eso tiene mucho sentido!
— Taylor Lopez
11

Python 2, 143.5 (287 bytes - 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 cuadrícula se genera con guiones; luego indexado y reemplazado con notas.

— Puertas de Zach
fuente
No lo he investigado demasiado, pero puede guardar bytes en la declaración jreemplazando cada coma con un espacio y llamando splitsin argumentos
— undergroundmonorail
No creo que necesitaras hacer eso, sigue siendo tu algoritmo, así que creo que mereces el representante, pero de todos modos logré deshacerme de él range. Lamentablemente, no puedes simplemente multiplicar la lista interna por 5 porque todos son el mismo objeto y cambiar uno cambia los otros: / ¡Pero vencimos a Perl (por ahora)!
— FryAmTheEggman
¿No podrías eliminar 6 bytes (1 para cada una de las primeras seis canciones) haciendo cosas como "<^><^>"=> "<^>"*2?
— El'endia Starman
scs="<"*8 No me gusta tu canción de Scarecrow.
— Casey Kuball
Cuando intento ejecutar esto, simplemente se detiene en la línea 2 y nunca termina.
— Cory Klein
7

Perl 5, 125 ( 320 260 250 Bytes -6x7 canciones% de bonificación -8% canción espantapájaros)

Yay, finalmente, una oportunidad para experimentar con esa sintaxis de hash 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)

Prueba

$ perl -M5.010 ocarina.pl scs
---^---------^---
-<-------------<-
------->->-------
-----V-----V-----
-----------------
— LukStorms
fuente
1
Use la qw()sintaxis en lugar de las comas gruesas ( %h=qw(zel <^><^> sas >'V><' ...)para guardar algunos bytes
— mob
1
@mob Ese consejo redujo más que solo "algunos" bytes. :) ¡Gracias!
— LukStorms
1
@Lse puede escribir de manera más sucinta como @L=('-')x17. Además, el hash principal se puede dejar anónimo como @B={qw(zel <^><^> ... scs <^V>>V^<)}->{$_}=~/./g.
— primo
1
Ya veo, esos son buenos trucos para evitar la función de división ligeramente detallada. Diez bytes más fueron sacrificados al vacío. cae
— LukStorms
5

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

Contando el shebang como 2, la entrada se toma de stdin.

Uso de la muestra

$ 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-
— primo
fuente
1
¿Usando la función vec de desplazamiento de bits para esto? Asombroso.
— LukStorms
@LukStorms Ojalá pudiera hacer 3 bits, en lugar de solo potencias de 2;)
— primo
4

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 hace el trabajo.

Pensé que podría vencer a Python usando estas codificaciones (me tomó mucho tiempo ._.), Pero no. Realmente no guardan muchos bytes todavía. ¿Alguna sugerencia?

Sí, eso es un signo negativo delante de la codificación de "ros". Eso es porque su 'hoja' termina con el carácter que significa 0en mi base-5, porque este truco negativo no funcionaría para las 'canciones fáciles' codificadas al duplicar lo que está codificado s. A menos que use quottal vez, pero luego no puede manejarlo p (-1)especialmente, ya quot (-5) = 0que la negatividad se desvanecería. Lo que sea.

— Leif Willerts
fuente
4

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

¡Gracias a Ismael Miguel y Blackhole por algunas ideas geniales para ahorrar más bytes!

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

Después de print"-esto, esta es una inserción literal de un retorno de carro. Puede traducirse a dos bytes en Windows.

Se incluyen todas las canciones de bonificación, incluida la canción del Espantapájaros.

Cada canción está representada en siete bytes de código. ¡Me gusta el nuevo puntaje porque con el viejo puntaje habría ganado solo un magro punto de bonificación en general!

Las ediciones recientes hacen que PHP genere muchas advertencias, por lo que para mantener las cosas bonitas y ordenadas, se desvían a ellas /dev/null.

Guardar como zelda.phpy ejecutar en la línea de comando:

$ 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-                                                                                                                                   
-----------------
¿Quiso decir "guardar como main.php"?
— Zach Gates
@ZachGates - Gracias por captar eso, los cambios realizados.
No es necesario el ()torno ($i-$c)en echo($i-$c)?'--':'-'.$z[$c-0];. Además, su cadena dentro de su splitse puede usar sin '. Y '/^'.$argv[1].'/'puede ser escrito como"/^$argv[1]/"
— Ismael Miguel
1
¡Gracias! ¿Creo que está permitido en CGSE canalizar advertencias a / dev / null para limpiar la salida?
@Blackhole - ¡gracias! Está vinculado con la presentación de Perl 5, haciendo bastante bien ...
4

Python 3 - 138.5 ( 292 280 277 bytes - 50%)

Limité algunos bytes del líder actual de Python mientras hacía el método de imprimir sobre la marcha en lugar del método de reemplazo.

Probar en línea

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)

Correr:

> python3 loz.py
bof [return]

Salida:

-----------------
-----------------
--------->--->---
-V---V-----V---V-
---A---A---------
— Taylor Lopez
fuente
Puede guardar algunos bytes utilizando en ['--',c+'-'][s[x]==c]lugar del condicional
— Ruth Franklin
Ooh, buena llamada, gracias!
— Taylor Lopez
3

Rubí, rev. 1, 192 - 50% = 96

El golf incluye:

eliminación de espacios en blanco entre grupos de letras en la cadena mágica (y revisión del denominador al final de la línea para /4). Eliminación de algún otro espacio en blanco innecesario.

conversión de las secuencias de escape en caracteres individuales (el intercambio de pila no las mostrará, por lo que he puesto ?como marcador de posición)

redefinición de gcomo una sola cadena que contiene cinco corridas de 17 -seguidas de nuevas líneas, en lugar de una matriz de cinco cadenas 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, rev 0, 223 - 50% = 111.5 (sin golf)

El código de entrada se reduce a 2 letras. Si comienza con un s, sse elimina, si comienza con una letra después s(solo se aplica a zella última letra eliminada, y si comienza con una letra antes de que sse elimine la letra del medio).

La cadena mágica (que en la versión sin golf contiene espacios para mayor claridad) contiene los códigos de 2 letras seguidos de los datos de la música. Se busca utilizando el operador de coincidencia =~que devuelve la posición en la cadena.

Hay exactamente una canción de 5, 7 y 8 notas (más scs que también tiene 8 notas). Estas, junto con una canción arbitraria de 6 notas, rosse agrupan al comienzo de la cuerda mágica para que el valor de ndado por la posición en la cuerda se puede usar para calcular la cantidad de notas que se tocarán. csse aprieta antes bf, y con el truncamiento cuando el número nse redondea hacia abajo, nos salimos con el cálculo correcto para ambos. Después del cuarto grupo, todas las canciones tienen 6 notas, por lo que si nes grande, el número de notas se reduce a un valor predeterminado de 6.

Se -configura una matriz de salida y las notas se sustituyen una por una. Los datos de música requeridos se extraen de la variable $'que contiene la parte de la cadena mágica original a la derecha del partido. De esta manera, los datos irrelevantes se ignoran.

Las notas se codifican 3 a la vez en la cadena mágica, justo después del código de la canción de 2 letras correspondiente. Se extraen con división por 5**(i%3)y gse actualiza un carácter en consecuencia. Al final del programa gse imprime.

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
— Level River St
fuente
2

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

Almacena cada nota como un byte ya que cada línea tiene 8 notas de largo. Recupera la representación binaria y luego la reemplaza con los caracteres correctos.

— Azul
fuente
1

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

Bastante simple, solo lee canciones codificadas como números de base 6.

— críptico se encuentra con Mónica
fuente
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.