Sua tarefa é escrever um programa que imprima quatro versos extraídos das letras da música "Hey Jude" dos 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

MAS

A única entrada que você pode usar para construir esses quatro versículos é 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"

Observe que alguns tokens têm um espaço precedido e que aspas não fazem parte dos tokens. Você pode usar qualquer formato para a lista e reorganizar a ordem dos tokens.

Sua saída gerada deve corresponder exatamente aos quatro versículos acima. Observe que \né usado para novas linhas e uma nova linha extra é adicionada após cada verso. Você pode usar este arquivo (MD5 :) 4551829c84a370fc5e6eb1d5c854cbecpara verificar sua saída.

Você pode usar o seguinte diagrama ferroviário para entender a estrutura dos versos (cada elemento representa um símbolo):

O menor código em bytes vence. Feliz golfe.

Geléia , 42 bytes

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

Experimente online!

Versão codificada.

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

Experimente online!

Versão alternativa, 114 bytes

Uma compactação um pouco melhor, mas infelizmente arruinada pelo código de descompactação maior.

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

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

Experimente online!

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

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

Experimente online!

-41 bytes: alterna do uso de variáveis ​​para o uso de caracteres como índices de matriz

-16 bytes: Alterne para um formato de entrada mais conveniente

-1 byte: não é necessário espaço entre putse"abv...

-1 byte: use $/global em vez de ?\nliteral

-3 bytes: use em gsub(/./)vez de.chars.map

-6 bytes: ligue -pe utilize $_. Obrigado Pavel !

Cada caractere na sequência mágica representa um índice na matriz de entrada. Eu preciso da variável zpara que eu só leia STDIN uma vez.

Eu poderia economizar algum custo do IO escrevendo um lambda aceitando uma matriz e retornando uma string. Isso requer um extra vno final, porque não está recebendo uma nova linha gratuita -p.

Ruby , 162 110 108 105 bytes (função)

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

Experimente online!

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)));}

Explicação:

Experimente online.

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`

Basicamente, converte os caracteres ASCII 0(48), através de E(69) para os índices de 0-indexados 0através 21com a i-48.

Python 3, 162 147 144 142 138 138 127 bytes

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

Experimente Online

Agradecimentos especiais a user202729 e Pavel .

05AB1E , 142 68 66 65 bytes

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

Experimente online!

-74 bytes graças ao EriktheOutgolfer, usando uma string compactada na base 255.

-2 bytes, revertendo a cadeia compactada para evitar a necessidade de concatenar três 0s

-1 byte, graças ao EriktheOutgolfer, alternando dois itens na matriz de entrada para evitar os 0s iniciais e removendo o 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
¶

Experimente online! Recebe entrada como uma lista de cadeias delimitada por nova linha.

Stax , 59 58 bytes

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

Execute e depure

A representação ascii correspondente do mesmo programa é essa.

`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!`é um literal compactado com um valor de "CDBGBLNOBQRSVWBBCEBHIJBMNPBQRUVWBBCFBHKJBLNOBQRSVWBBCDBGBLNPBQRTUVBB". Os caracteres representam índices na tabela de tokens. Este programa adiciona outro token para representar uma nova linha. Não está na entrada, mas foi adicionado durante a execução. O resto do programa funciona assim.

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

Função 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]);}

Experimente online!

Vermelho , 133 bytes

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

Experimente online!

Ungolfed

t é um bloco com a 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;}

Experimente online!

Mathematica, 102 bytes

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

Função pura. Pega uma lista de cadeias como entrada e retorna uma cadeia como saída. Apenas codifica todos os índices de token, da mesma forma que outras respostas.

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

Experimente online!

Salvou alguns bytes com uma abordagem diferente da maioria das outras respostas.

O número de tokens possíveis em cada linha é o seguinte

Line number   Tokens 
1             4
2             5
3             5
4             7

A sequência mágica contém um caractere por linha, que é interpretado como um bitmap, com o qual até 7 tokens disponíveis devem ser impressos para cada uma das 16 linhas da música.

a[i%7-1+i%28/7*5] itera pelos tokens de cada linha, deslocando-se 5 para cada nova linha e com um deslocamento de 1 para explicar o fato de que a primeira linha possui apenas 4 tokens.

Para as linhas 1-3, apenas os bits de 64 a 4 são usados ​​- não usar os bits de 2 e 1 evita a impressão de tokens da próxima linha. para a linha 4, todos os 7 bits de 64 a 1 são usados.