Su tarea es escribir un programa que imprima los siguientes cuatro versículos extraídos de la letra de la canción "Hey Jude" de The Beatles (© Sony / ATV Music Publishing LLC):

Hey Jude, don't make it bad\n
Take a sad song and make it better\n
Remember to let her into your heart\n
Then you can start to make it better\n
\n
Hey Jude, don't be afraid\n
You were made to go out and get her\n
The minute you let her under your skin\n
Then you begin to make it better\n
\n
Hey Jude, don't let me down\n
You have found her, now go and get her\n
Remember to let her into your heart\n
Then you can start to make it better\n
\n
Hey Jude, don't make it bad\n
Take a sad song and make it better\n
Remember to let her under your skin\n
Then you'll begin to make it\n
\n

PERO

La única entrada que puede usar para construir estos cuatro versículos es esta lista de tokens:

"Hey Jude, don't"
" make it bad"
" be afraid"
" let me down"
"Take a sad song and make it better"
"You"
" were made to go out"
" and get her"
" have found her, now go"
"Remember to"
"The minute you"
" let her"
" into your heart"
" under your skin"
"Then"
" you"
" can start"
"'ll"
" begin"
" to make it"
" better"

Tenga en cuenta que algunos tokens tienen un espacio precedido y que las comillas adjuntas no son parte de los tokens. Puede utilizar cualquier formato para la lista y reorganizar el orden de los tokens.

Su salida generada tiene que coincidir exactamente con los cuatro versos anteriores. Tenga en cuenta que \nse usa para líneas nuevas y se agrega una línea nueva adicional después de cada verso. Puede usar este archivo (MD5:) 4551829c84a370fc5e6eb1d5c854cbecpara verificar su salida.

Puede usar el siguiente diagrama de ferrocarril para comprender la estructura de los versos (cada elemento representa una ficha):

El código más corto en bytes gana. Feliz golf.

Jalea , 42 bytes

;⁷“Ṙç€ṘḋḷŒø|Ṁ2kḤ⁽⁼SƁẒVṿẎj]ð⁵ṀƒƤ)÷Ƒ¦Ẋ½Iɠ⁻’ṃ

Pruébalo en línea!

Versión de hardcoding.

Entrada:

["Hey Jude, don't", ' make it bad', 'Take a sad song and make it better', 'Remember to', ' let her', ' into your heart', 'Then', ' you', ' can start', ' to make it', ' better', ' be afraid', 'You', ' were made to go out', ' and get her', 'The minute you', ' under your skin', ' begin', ' let me down', ' have found her, now go', "'ll"]

JavaScript (ES6), 108 bytes

a=>`01
4
9bc
efgjk

02
567
abd
efijk

03
587
9bc
efgjk

01
4
9bd
efhij

`.replace(/./g,n=>a[parseInt(n,36)])

Pruébalo en línea!

Versión alternativa, 114 bytes.

Una compresión ligeramente mejor, pero tristemente arruinada por el código de descompresión más grande.

a=>`835fc3cbbd3
84db3db4bbdb3
85cd1cc3cbbd3
835fc4bbcb3

`.replace(/./g,n=>a[n='0x'+n,i=n%8&&n%8-2+i]+[`
`[n>>3]])

Pruébalo en línea!

Rubí + -p, 177 136 120 118 115 109 bytes (programa completo)

$_="abvevjlmvopqtuvvacvfghvklnvopstuvvadvfihvjlmvopqtuvvabvevjlnvoprstv".gsub(/./){|c|(eval$_)[c.ord-97]||$/}

Pruébalo en línea!

-41 bytes: cambie de usar variables a usar caracteres como índices de matriz

-16 bytes: cambia a un formato de entrada más conveniente

-1 byte: no se necesita espacio entre putsy"abv...

-1 byte: use $/global en lugar de ?\nliteral

-3 bytes: usar en gsub(/./)lugar de.chars.map

-6 bytes: llama -py utiliza $_. Gracias pavel !

Cada carácter en la cadena mágica representa un índice en la matriz de entrada. Necesito la variable zpara que solo lea de STDIN una vez.

Podría ahorrar algunos costos de IO escribiendo una lambda que acepte una matriz y devuelva una cadena. Esto requiere un extra val final, porque no está obteniendo una nueva línea gratuita -p.

Ruby , 162 110 108 105 bytes (función)

->z{"abvevjlmvopqtuvvacvfghvklnvopstuvvadvfihvjlmvopqtuvvabvevjlnvoprstvv".gsub(/./){|c|z[c.ord-97]||$/}}

Pruébalo en línea!

Java 8, 241 233 141 140 138 bytes

a->{a.add("\n");"01E4E9;<E>?@CDEE02E567E:;=E>?@CDEE03E587E91<E>?@CDEE01E4E91=E>?ABCEE".chars().forEach(i->System.out.print(a.get(i-48)));}

Explicación:

Pruébalo en línea.

a->{                  // Method with ArrayList<String> parameter and no return-type
 a.add("\n");         //  Add a new-line as last item (index 21) to the input-List
 "01E4E9;<E>?@CDEE02E567E:;=E>?@CDEE03E587E91<E>?@CDEE01E4E91=E>?ABCEE".chars().forEach(i->
                      //  Loop over the bytes of this String above
   System.out.print(  //   Print:
     a.get(i-48)));}  //    The String in the list at index `i-48`

Básicamente, convierte los caracteres ASCII 0(48) a través de E(69) a los índices 0-indexado 0a través de 21la i-48.

Python 3, 162 147 144 142 138 127 bytes

lambda k,x=b'ABVCVDEFVGHIJKVVALVMNOVPEWQVGHRJKVASVVMTOV':"".join([(k+['\n',' '])[i-65]for i in x+x[5:16]+x[:4]+b'VDEWQVGHURJ'])

Pruébalo en línea

Un agradecimiento especial a user202729 y Pavel .

05AB1E , 142 68 66 65 bytes

`¶)•7/è¸ĀuVI{è:÷MDS.₁bö¼d@ÉÃƶõî›Λðë’OŒβι"žHƒö>“ÃaÈǝõöÓ∍¿þœθÀ•2ôèJ

Pruébalo en línea!

-74 bytes gracias a EriktheOutgolfer, utilizando una cadena comprimida base-255.

-2 bytes invirtiendo la cadena comprimida para evitar tener que concatenar tres ceros

-1 byte gracias a EriktheOutgolfer, al cambiar dos elementos en la matriz de entrada para evitar los 0 iniciales, y así eliminar el comando Reverse R.

Retina 0.8.2 , 115 bytes

^
12F5F:<=F?@ADEFF13F678F;<>F?@CDEFF14F698F:<=F?@ADEFF12F5F:<>F?@BCDF¶
{`1(?=.*¶(.*))
$1
^(.*)¶.*
$1
}T`1-E`0-D
F
¶

Pruébalo en línea! Toma datos como una lista de cadenas delimitada por nueva línea.

Stax , 59 58 bytes

îòÖ╥╬╬╞:,y╓ønä⌠╦╒ï╦≤x◘‼ε╩ⁿ◙ΓZ►e«qpôr╡"╣Ü≥┤╢┴;╡ÑkAú0:=;m╠╠x

Ejecutar y depurarlo

La representación ascii correspondiente del mismo programa es esta.

`ORIpY$T&z{m6Y=>mR)_ .VQ)eN70e[:0yO8j$^RN[ Bp{IN/$|"3^;G#^&lv!`FAx+@]p

`ORIpY$T&z{m6Y=>mR)_ .VQ)eN70e[:0yO8j$^RN[ Bp{IN/$|"3^;G#^&lv!`es un literal comprimido con un valor de "CDBGBLNOBQRSVWBBCEBHIJBMNPBQRUVWBBCFBHKJBLNOBQRSVWBBCDBGBLNPBQRTUVBB". Los caracteres representan índices en la tabla de tokens. Este programa agrega otro token para representar una nueva línea. No está en la entrada, sino que se agrega durante la ejecución. El resto del programa funciona así.

F           for each character, execute the rest of the program
 A          integer literal 10, character code of newline
  x+        append 10 to the input array
    @       get element at index, using wrap-around
                the list is size 22, and B is 66, so B gets the first token
     ]      wrap the result in a singleton array.
                this effectively turns 10 into "\n"
      p     print without newline

Función C (gcc), 139 bytes

i,m;f(char**s){for(i=0;i<68;)m="AB@E@JLM@OPQTU@@AC@FGH@KLN@OPSTU@@AD@FIH@JLM@OPQTU@@AB@E@JLN@OPRST@@"[i++],printf(m^64?"%s":"\n",s[m-65]);}

Pruébalo en línea!

Rojo , 133 bytes

foreach c{abzezjlmzopqtuzzaczfghzklnzopstuzzadzfihzjlmzopqtuzzabzezjlnzoprstzz}[prin either c =#"z"["^/"][t/(to-integer c -#"a"+ 1)]]

Pruébalo en línea!

Sin golf

t es un bloque con la lista de tokens

s:{abzezjlmzopqtuzzaczfghzklnzopstuzzadzfihzjlmzopqtuzzabzezjlnzoprstzz}
foreach c s[                           ; for each character in s
    prin either c = #"z"               ; if it's a 'z' 
        ["^/"]                         ; print CR
        [t/(to-integer c - #"a" + 1)]  ; otherwise find which token to print
]                                      ; by mapping its offset to the alphabet

D , 166 bytes

import std.algorithm,std.range;T f(T)(T[]s){return"abvevjlmvopqtuvvacvfghvklnvopstuvvadvfihvjlmvopqtuvvabvevjlnvoprstvv".map!((int a){return(s~["\n"])[a-97];}).join;}

Pruébalo en línea!

Mathematica, 102 bytes

""<>Append[#,"
"][[36^^ajikrj7lg8pya7wgtt43pvrilsik1dea1uht6mx3go33m4mjj02hb4wi9w3~IntegerDigits~23]]&

Pura función. Toma una lista de cadenas como entrada y devuelve una cadena como salida. Simplemente codifica todos los índices de tokens, de manera similar a otras respuestas.

Ruby , 97 bytes

->a{112.times{|i|$><<a[i%7-1+i%28/7*5]*("0@Xg(44k$,Xg0@Tz"[i/7].ord>>~i%7&1)+$/*(i%7/6+i%28/27)}}

Pruébalo en línea!

Guardado algunos bytes con un enfoque diferente a la mayoría de las otras respuestas.

El número de tokens posibles en cada línea es el siguiente

Line number   Tokens 
1             4
2             5
3             5
4             7

La cadena mágica contiene un carácter por línea, que se interpreta como un mapa de bits del cual se imprimirán hasta 7 tokens disponibles para cada una de las 16 líneas de la canción.

a[i%7-1+i%28/7*5] itera a través de los tokens de cada línea, cambiando 5 por cada nueva línea, y con un desplazamiento de 1 para tener en cuenta el hecho de que la primera línea tiene solo 4 tokens.

Para las líneas 1-3, solo se usan los bits de 64 a 4; no usar los bits de 2 y 1 evita imprimir tokens desde la siguiente línea. para la línea 4, se utilizan los 7 bits de 64 a 1.