Il tuo compito è quello di scrivere un programma che stampa seguendo quattro versetti estratti dal testo della canzone dei Beatles "Hey Jude" (© 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

MA

L'unico input che ti è consentito utilizzare per costruire questi quattro versetti è questo elenco di token:

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

Si noti che alcuni token hanno uno spazio preceduto e che le virgolette racchiuse non fanno parte dei token. Sei libero di utilizzare qualsiasi formato per l'elenco e di riorganizzare l'ordine dei token.

L'output generato deve corrispondere esattamente ai quattro versetti sopra. Nota che \nviene usato per le nuove righe e una nuova riga aggiuntiva viene aggiunta dopo ogni verso. È possibile utilizzare questo file (MD5:) 4551829c84a370fc5e6eb1d5c854cbecper verificare l'output rispetto.

Puoi usare il seguente diagramma della ferrovia per capire la struttura dei versetti (ogni elemento rappresenta un token):

Vince il codice più breve in byte. Buon golf.

Gelatina , 42 byte

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

Provalo online!

Versione hardcoding.

Ingresso:

["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 byte

a=>`01
4
9bc
efgjk

02
567
abd
efijk

03
587
9bc
efgjk

01
4
9bd
efhij

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

Provalo online!

Versione alternativa, 114 byte

Una compressione leggermente migliore, ma purtroppo rovinata dal codice di decompressione più grande.

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

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

Provalo online!

Ruby + -p, 177 136 120 118 115 109 byte (programma completo)

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

Provalo online!

-41 byte: passa dall'uso delle variabili all'utilizzo dei caratteri come indici di array

-16 byte: passa a un formato di input più conveniente

-1 byte: nessuno spazio necessario tra putse"abv...

-1 byte: utilizzare $/globale anziché ?\nletterale

-3 byte: utilizzare gsub(/./)invece di.chars.map

-6 byte: chiama -pe usa $_. Grazie Pavel !

Ogni carattere nella stringa magica rappresenta un indice nella matrice di input. Ho bisogno della variabile in zmodo che legga da STDIN solo una volta.

Potrei risparmiare alcuni costi da IO scrivendo un lambda che accetta un array e restituisce una stringa. Ciò richiede un extra valla fine, perché non sta ottenendo una newline gratuita da -p.

Rubino , 162 110 108 105 byte (funzione)

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

Provalo online!

Java 8, 241 233 141 140 138 byte

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

Spiegazione:

Provalo 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`

In pratica converte i caratteri ASCII da 0(48) a E(69) in indici con indice 0 0fino 21a i-48.

Python 3, 162 147 144 142 138 127 byte

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

Provalo online

Un ringraziamento speciale a user202729 e Pavel .

05AB1E , 142 68 66 65 byte

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

Provalo online!

-74 byte grazie a EriktheOutgolfer, usando una stringa compressa base-255.

-2 byte invertendo la stringa compressa per evitare di concatenare tre 0

-1 byte grazie a EriktheOutgolfer, cambiando due elementi nell'array di input per evitare gli 0 iniziali e rimuovendo così il comando Reverse R.

Retina 0.8.2 , 115 byte

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

Provalo online! Accetta input come un elenco di stringhe delimitato da nuova riga.

Stax , 59 58 byte

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

Esegui ed esegui il debug

La corrispondente rappresentazione ASCII dello stesso programma è questa.

`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!`è un valore letterale compresso con un valore di "CDBGBLNOBQRSVWBBCEBHIJBMNPBQRUVWBBCFBHKJBLNOBQRSVWBBCDBGBLNPBQRTUVBB". I caratteri rappresentano gli indici nella tabella token. Questo programma aggiunge un altro token per rappresentare una nuova riga. Non è nell'input, ma aggiunto durante l'esecuzione. Il resto del programma funziona in questo modo.

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

Funzione C (gcc), 139 byte

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

Provalo online!

Rosso , 133 byte

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

Provalo online!

Ungolfed

t è un blocco con l'elenco di token

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 byte

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

Provalo online!

Mathematica, 102 byte

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

Funzione pura. Prende un elenco di stringhe come input e restituisce una stringa come output. Codifica semplicemente tutti gli indici dei token, in modo simile alle altre risposte.

Rubino , 97 byte

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

Provalo online!

Salvati alcuni byte con un approccio diverso alla maggior parte delle altre risposte.

Il numero di possibili token in ciascuna riga è il seguente

Line number   Tokens 
1             4
2             5
3             5
4             7

La stringa magica contiene un carattere per riga, che viene interpretato come una bitmap di cui devono essere stampati fino a 7 token disponibili per ciascuna delle 16 righe della canzone.

a[i%7-1+i%28/7*5] scorre attraverso i token di ogni riga, spostandosi di 5 per ogni nuova riga e con un offset di 1 per tenere conto del fatto che la prima riga ha solo 4 token.

Per le righe 1-3 vengono utilizzati solo i bit da 64 a 4, non utilizzando i bit 2 e 1 si evita di stampare i token dalla riga successiva. per la linea 4, vengono utilizzati tutti i 7 bit da 64 a 1.