La sfida è in realtà estremamente semplice. Scegli 5 lettere distinte (puoi semplicemente scegliere le 5 che ti consentono il codice più corto, se lo desideri) e inviarle alla console. Tuttavia, il colpo di scena è che devono appartenere al seguente elenco:

 AAA      BBBB       CCCC     DDDD      EEEEE     FFFFF      GGG      H   H
A   A     B   B     C         D   D     E         F         G         H   H
AAAAA     BBBB      C         D   D     EEEE      FFFF      G  GG     HHHHH
A   A     B   B     C         D   D     E         F         G   G     H   H
A   A     BBBB       CCCC     DDDD      EEEEE     F          GGG      H   H


IIIII         J     K   K     L         M   M     N   N      OOO 
  I           J     K  K      L         MM MM     NN  N     O   O
  I           J     KKK       L         M M M     N N N     O   O
  I       J   J     K  K      L         M   M     N  NN     O   O
IIIII      JJJ      K   K     LLLLL     M   M     N   N      OOO 


PPPP       QQQ      RRRR       SSSS     TTTTT     U   U     V   V     W   W
P   P     Q   Q     R   R     S           T       U   U     V   V     W   W
PPPP      Q   Q     RRRR       SSS        T       U   U     V   V     W   W
P         Q  QQ     R  R          S       T       U   U      V V      W W W
P          QQQQ     R   R     SSSS        T        UUU        V        W W 


X   X     Y   Y     ZZZZZ
 X X       Y Y         Z 
  X         Y         Z  
 X X        Y        Z   
X   X       Y       ZZZZZ

Regole aggiuntive:

5 della stessa lettera non sono ammessi, nessuna scelta di ripetizione.
Ogni lettera deve usare la capitale di se stessa come carattere ASCII per disegnarla.
Ogni output di una lettera deve trovarsi sulla "stessa riga" e avere 5 spazi tra ogni lettera.
Puoi scegliere le 5 lettere che vuoi, questo ti permetterà di riutilizzare un po 'di codice e ridurre il numero di byte. Capire quali lettere ti permetteranno di farlo nel modo più efficiente fa parte della sfida.
Gli spazi finali sono accettabili.
È accettabile una sola nuova riga finale, ma non più di una nuova riga finale.
Questo è code-golf, vince il conteggio di byte più basso.

Esempi:

ABCDE

 AAA      BBBB       CCCC     DDDD      EEEEE
A   A     B   B     C         D   D     E    
AAAAA     BBBB      C         D   D     EEEE 
A   A     B   B     C         D   D     E    
A   A     BBBB       CCCC     DDDD      EEEEE

EFLIP

EEEEE     FFFFF     L         IIIII     PPPP 
E         F         L           I       P   P
EEEE      FFFF      L           I       PPPP 
E         F         L           I       P    
EEEEE     F         LLLLL     IIIII     P

PAZZO

 CCCC     RRRR       AAA      ZZZZZ     Y   Y
C         R   R     A   A        Z       Y Y 
C         RRRR      AAAAA       Z         Y  
C         R  R      A   A      Z          Y  
 CCCC     R   R     A   A     ZZZZZ       Y

Non aver paura di inviare più di una risposta con lettere o strategie diverse ogni volta, questo può essere realizzato in diversi modi.

code-golf ascii-art kolmogorov-complexity

— Urna di polpo magico
fonte

21

Mi piace che tu possa scegliere quali lettere produrre; che aggiunge un altro livello al golf. Problemi minori con l'arte ASCII: ci sono un sacco di spazi finali e due Jsecondi.

— ETHproductions

2

Puoi aggiungere un bonus per prendere 5 lettere come input?

— Mukul Kumar,

5

I bonus sono disapprovati e ci sono troppe risposte per apportare un cambiamento drastico come quello. Ma ti darò un voto;).

— Magic Octopus Urn

1

@Titus Non so perché ne avresti bisogno; il trailing ha più senso. Se riesci a spiegare logicamente in che modo una limitazione della lingua che stai utilizzando e non la logica che hai scritto sta causando un vantaggio \n, lo permetterò.

— Magic Octopus Urn,

1

@Titus quindi no. Le nuove righe e gli spazi finali sono dovuti alle limitazioni programmatiche di alcune lingue.

— Magic Octopus Urn,

12

Gelatina , 41 byte

LICTE

“LICTE”Kż
141D+“ȷɓSɠ’“ðƁ ƥ“JrŀṘ’jḃ11Ç€ŒṙY

TryItOnline!

Idea

Utilizzare una decodifica della lunghezza della corsa con lettere che abbiano il centro il più simile possibile con una sola lunghezza della corsa di ciascun "valore pixel" per riga per lettera.

Inserire un inizio piatto come "L" per evitare valori di decodifica della lunghezza della corsa diversi per le righe.

Posiziona una lettera diversa (impossibile trovare 5) delle tre file centrali alla fine in modo che la differenza più piccola possa essere aggiunta aritmeticamente.

Produzione voluta; le lunghezze della corsa; e questi convertiti dalla base 11:

                                                  L,  , I,  , C,  , T,  , E   value
                                                  -------------------------
L         IIIII      CCCC     TTTTT     EEEEE     1, 9, 5, 6, 4, 5, 5, 5, 5   399633415
L           I       C           T       E         1,11, 1, 7, 1,11, 1, 7, 1   431646160+1
L           I       C           T       EEEE      1,11, 1, 7, 1,11, 1, 7, 4   431646160+4
L           I       C           T       E         1,11, 1, 7, 1,11, 1, 7, 1   431646160+1
LLLLL     IIIII      CCCC       T       EEEEE     5, 5, 5, 6, 4, 7, 1, 7, 5   1179122455

I tre valori 399633415, 431646160e 1179122455in basso 250come gelatina indici di pagina di codice sono poi ðƁ ƥ, ȷɓSɠe JrŀṘche possono essere utilizzati per incapsulare le informazioni run-length.

Il codice

“LICTE”Kż - Link 1, make a run length encoding for a row of the output: row's run lengths
“LICTE”    - list of characters "LICTE"
       K   - join with spaces   "L I C T E"
        ż  - zip with input     e.g. [['L',1],[' ',9],['I',5],[' ',6],['C',4],[' ',5],['T',5],[' ',5],['E',5]]

141D+“ȷɓSɠ’“ðƁ ƥ“JrŀṘ’jḃ11Ç€ŒṙY - Main link
141D                            - 141 as a decimal list: [1, 4, 1]
     “ȷɓSɠ’                     - 431646160
    +                           - add: [431646161, 431646164, 431646161]
           “ðƁ ƥ“JrŀṘ’          - list [399633415,1179122455]
                      j         - join: [399633415, 431646161, 431646164, 431646161, 1179122455]
                       ḃ11      - convert to bijective base 11: [[1, 9, 5, 6, 4, 5, 5, 5, 5], [1, 11, 1, 7, 1, 11, 1, 7, 1], [1, 11, 1, 7, 1, 11, 1, 7, 4], [1, 11, 1, 7, 1, 11, 1, 7, 1], [5, 5, 5, 6, 4, 7, 1, 7, 5]]
                          Ç€    - call last link (1) as a monad for €ach
                            Œṙ  - run-length decode e.g. [['L',1],[' ',9],['I',5],...]
                                                            -> "L         IIIII..."
                              Y - join with line feeds

— Jonathan Allan
fonte

1

Hai fatto l'idea che inizialmente non ero abbastanza intelligente da fare in 05AB1E !!! Ottimo lavoro amico.

— Magic Octopus Urn

32

Carbone , 51 49 byte (ECXKI)

Ｇ←⁵↓³→⁴EＭ⁷→Ｇ↑²↗²→⁴CＭ⁶→ＧＨ↘↗³XＭ⁶→ＧＨ↓→↗³KＭ⁸→ＰTIII‖Ｏ↓

Uscite

EEEEE      CCCC     X   X     K   K     IIIII
E         C          X X      K  K        I  
EEEE      C           X       KKK         I  
E         C          X X      K  K        I  
EEEEE      CCCC     X   X     K   K     IIIII

Provalo online!

Utilizzando caratteri simmetrici verticalmente, disegna le metà superiori e poi riflette. Molti di questi usano Polygon ( Ｇ) e PolygonHollow ( ＧＨ) per disegnare una serie di segmenti di linea collegati con un carattere particolare. Ipuò essere fatto più facilmente con MultiPrint ( Ｐ), usando Tcome direzione.

Nota: PolygonHollow disegna semplicemente i segmenti specificati, senza completare il poligono o riempirlo. Il poligono completerà e riempirà (non quello che vogliamo) se il poligono può essere completato con una semplice linea in una delle otto direzioni cardinali o intercardinali. Altrimenti, si comporta come PolygonHollow, per un risparmio di un byte.

L'ordine dei personaggi è stato scelto per richiedere solo mosse orizzontali dal punto finale di uno all'inizio del successivo. Ecco come procede il cursore:

— DLosc
fonte

2

Bello. Stavo cercando una soluzione di carbone, ma la mancanza di documentazione mi ha ucciso onestamente

— Bassdrop Cumberwubwubwub

6

@Bassdrop Sì, stiamo ... um ... ci stiamo lavorando. [va ad aggiungere ＧＨai documenti]

— DLosc

19

PowerShell v2 +, 138 128 114 112 106 105 byte (LICTD)

"L1    IIIII1 CCCC1TTTTT1DDDD
$("L11 I1  C11 T1  D   D
"*3)LLLLL1IIIII1 CCCC1  T1  DDDD"-replace1,'     '

L'idea è di massimizzare gli spazi tra le lettere in modo da poter ottenere compressioni ripetute.

Prende in prestito il trucco di deduplicazione della fila centrale dalla risposta di Florent . Hai salvato 6 byte grazie a Ben Owen usando la moltiplicazione delle stringhe per le tre file centrali e un byte aggiuntivo grazie a Matt .

L'output è simile al seguente a 227 byte, per una riduzione del 53,7% -

PS C:\Tools\Scripts\golfing> .\5-favorite-letters.ps1
L         IIIII      CCCC     TTTTT     DDDD
L           I       C           T       D   D
L           I       C           T       D   D
L           I       C           T       D   D
LLLLL     IIIII      CCCC       T       DDDD

— AdmBorkBork
fonte

Adoro quando la prima risposta è qualcosa che non ti aspettavi affatto. Metodo pulito.

— Magic Octopus Urn,

2

Che ne dici $("L11 I1 C11 T1 D D`n"*3)invece delle 3 linee centrali

— Ben Owen,

@BenOwen Ottima idea - grazie!

— AdmBorkBork,

13

JavaScript, 110 109 byte (CLOUD)

` CCCC5L9 OOO6U3U5DDDD
${x=`C9L9O3O5U3U5D3D
`,x+x+x} CCCC5LLLLL6OOO7UUU6DDDD`.replace(/\d/g,c=>" ".repeat(c))

Mostra snippet di codice

console.log(
` CCCC5L9 OOO6U3U5DDDD
${x=`C9L9O3O5U3U5D3D
`,x+x+x} CCCC5LLLLL6OOO7UUU6DDDD`.replace(/\d/g,c=>" ".repeat(c))
)

Espandi frammento

L'output è di 227 byte:

 CCCC     L          OOO      U   U     DDDD
C         L         O   O     U   U     D   D
C         L         O   O     U   U     D   D
C         L         O   O     U   U     D   D
 CCCC     LLLLL      OOO       UUU      DDDD

— Florent
fonte

1

Bel uso della deduplicazione nelle tre file centrali.

— AdmBorkBork,

12

ES6 (Javascript), 194, 181 byte (IGOLF / ANY)

Questo è lungo e non è realmente ottimizzato (almeno non ancora), ma può essere modificato per stampare qualsiasi messaggio particolare, cambiando solo i dati bitmap.

EDIT: sostituito interno ridurre con mappa , utilizzare bit shift per il riempimento

golfed

[0x1f73a1f,0x484610,0x49c61e,0x48c610,0x1f73bf0].map(r=>[0,1,2,3,4].map(p=>('0000'+(r>>(20-p*5)<<5).toString(2)).substr(-10).replace(/(1|0)/g,b=>' IGOLF'[(p+1)*b])).join``).join`\n`

dimostrazione

[0x1f73a1f,0x484610,0x49c61e,0x48c610,0x1f73bf0].map(r=>[0,1,2,3,4].map(p=>('0000'+(r>>(20-p*5)<<5).toString(2)).substr(-10).replace(/(1|0)/g,b=>' IGOLF'[(p+1)*b])).join``).join`\n`

IIIII      GGG       OOO      L         FFFFF     
  I       G         O   O     L         F         
  I       G  GG     O   O     L         FFFF      
  I       G   G     O   O     L         F         
IIIII      GGG       OOO      LLLLL     F

Teoria

Prendi una lettera:

IIIII      
  I        
  I        
  I        
IIIII

convertilo in matrice binaria (bitmap)

fare lo stesso per altre 4 lettere, scansionare una riga, togliendo "top" da 5 bit ciascuno

11111 01110 01110 10000 11111

converti in una stringa esadecimale (dovrebbe usare qui base36 o ASCII stampabile)

0x1f73a1f

applica lo stesso algoritmo ad altre 4 linee per ottenere la bitmap.

Rendering nell'ordine inverso.

— zeppelin
fonte

1

Puoi rimuovere le parentesi nella regex per salvare 2 byte :-)

— ETHproductions

1

[32979487,4736528,4834846,4769296,32979952] è più corto della sua rappresentazione esadecimale

— Florent

@ETHproductions È vero, lo userò, quando tornerò per ottimizzarlo. Grazie!

— Zeppelin,

1

È possibile sostituire /(1|0)/gcon /\d/gper salvare alcuni byte. Inoltre \npotrebbe essere sostituito da una nuova linea reale.

— Florent,

> è più corto della sua rappresentazione esadecimale Sì, questo è vero (a causa di 0x), almeno per queste lettere specifiche, probabilmente lo comprimerò in una stringa esadecimale continua (o anche Base32 / Base36 / ASCII), alla successiva iterazione . > È possibile sostituire / (1 | 0) / g con / \ d / g per salvare alcuni byte. Inoltre \ n potrebbe essere sostituito da una nuova riga effettiva. Sì, grazie per i tuoi consigli, li userò una volta tornato a questo.

— Zeppelin,

12

PHP, 107 104 102 94 86 byte

Ok, sono sicuro di avere la fonte più piccola possibile con questo metodo ora. Ho scritto una sceneggiatura per generare e poi decomprimere ogni possibile combinazione di cinque lettere. Esistono due soluzioni che corrispondono per la compressione più breve: LODIC e LDOIC. Vado con il primo perché è più divertente da dire.

Fonte:

<?=gzinflate(base64_decode('81GAA39/fwjDBQggLE8QgDCdgYDLB6EYioGqoRisHkrTSCUIEOtWAA'));

Produzione:

% php foo.php
L          OOO      DDDD      IIIII      CCCC
L         O   O     D   D       I       C
L         O   O     D   D       I       C
L         O   O     D   D       I       C
LLLLL      OOO      DDDD      IIIII      CCCC

— Alex Howansky
fonte

3

puoi salvare 2 byte rilasciando la 's: la stringa verrà trattata come una costante con un valore di se stessa.

— user59178

Dannazione, mi dimentico sempre di farlo. :)

— Alex Howansky,

Se L fosse la tua ultima lettera, risparmierai anche più byte.

— Magic Octopus Urn

Bello sfruttamento di una scappatoia.

— Ismael Miguel,

2

La creatività è soggettiva e incommensurabile. L'obiettivo della sfida è ridurre al minimo le dimensioni del codice e questa è la voce più breve per un linguaggio non golf.

— Alex Howansky,

10

05AB1E , 44 byte

Questo è stato divertente.
Sento che devo tornare e provare a giocarci ancora un po 'quando ho tempo.

Utilizza la codifica CP-1252 .
Ispirato dalla risposta di carusocomputing .

ECOIH

‘ÓÑOIHH‘SðýJ3×S•Td<UÕ‘áÓ?Â¢tWvkÔÚ•S)øü×J3äû»

Provalo online!

Spiegazione

‘ÓÑOIHH‘spinge la corda "ECOOIHH".

SðýJ3×Sunisce la stringa per spazi, la ripete tre volte e la converte in un elenco.
L'elenco risultante è ['E', ' ', 'C', ' ', 'O', ' ', 'O', ' ', 'I', ' ', 'H', ' ', 'H', 'E', ' ', 'C', ' ', 'O', ' ', 'O', ' ', 'I', ' ', 'H', ' ', 'H', 'E', ' ', 'C', ' ', 'O', ' ', 'O', ' ', 'I', ' ', 'H', ' ', 'H'].

•Td<UÕ‘áÓ?Â¢tWvkÔÚ•spinge il numero 564631055513119191317171314619131717500.

S)ø comprime l'elenco e il numero insieme.

ü×Jesegue la ripetizione di stringhe a coppie e le unisce.
Il risultato è la stringa EEEEE CCCC OOO IIIII H HE C O O I H HEEEE C O O I HHHHH.

3äû»lo divide in 3 pezzi, aggiunge il primo e il secondo pezzo in ordine inverso e si unisce alle nuove linee.

— Emigna
fonte

13

" •Td<UÕ‘áÓ?Â¢tWvkÔÚ•spinge il numero 564631055513119191317171314619131717500" perché non dovrebbe ...

— geisterfurz007

3

@ geisterfurz007: Per essere più precisi, è la rappresentazione base-214 del numero base-10 :)

— Emigna,

Quindi potenzialmente se potessi salire su una base più alta, la tua stringa diventerebbe più corta?

— geisterfurz007,

@ geisterfurz007: se potessimo sì. Purtroppo 214 è il massimo in 05AB1E.

— Emigna,

3

Puoi battere Jelly, io credo in te; 3 byte rimasti per andare ahah!

— Magic Octopus Urn

9

JavaScript (ES6), 96 byte (DIOCL)

`${x="DDDD6IIIII6OOO7CCCC5L"}
${y=`D3D7I7O3O5C9L
`,y+y+y+x}LLLL`.replace(/\d/g,d=>" ".repeat(d))

L'idea qui è non solo di rendere identiche le tre linee centrali, ma anche di rendere la prima riga quasi identica all'ultima. Dato che ci sono solo 4 lettere che si adattano perfettamente a questa descrizione CDIO, Lè la migliore opzione successiva, poiché richiede solo 4 caratteri aggiunti alla fine della stringa.

Come per la risposta di Florent , questo è uno snippet che restituisce il risultato. Aggiungi 3 byte se deve essere una funzione.

Test snippet

Mostra snippet di codice

console.log(`${x="DDDD6IIIII6OOO7CCCC5L"}
${y=`D3D7I7O3O5C9L
`,y+y+y+x}LLLL`.replace(/\d/g,d=>" ".repeat(d)))

Espandi frammento

— ETHproductions
fonte

È possibile salvare un byte inserendo il Dprimo.

— Neil,

@ Grazie Grazie. Ho dovuto spostare il Cpassato Ie Oanche

— ETHproductions

Ah, giusto, non puoi avere Isubito dopo C, anche se in modo interessante, che migliora la mia soluzione Batch, per lo stesso motivo.

— Neil,

9

Bash + coreutils con figlet, 55440 soluzioni, 112 106 byte ciascuno

 set H E L P D;for l;do figlet -f banner $l|sed "s/.//3;s/.//5;s/#/$l/g;2d;5d">$l;done;paste $@|expand -t10

Produzione:

HH EEEEE L PPPP DDDD  
HHELPPDD 
HHHHH EEEE L PPPP DD 
HHELPDD 
HH EEEEE LLLLL P DDDD

Ehi, abbiamo già un programma per l'arte ASCII! Il carattere banner fa quasi il lavoro, tranne per il fatto che genera 7x7 lettere. Hmm, rimuoviamo solo la 3a e la 5a colonna e la 2a e la 5a riga, e vediamo cosa dà ...

Si scopre che molte lettere verranno emesse nel modo richiesto, vale a dire, BDEFHJLPTU Z.

È sufficiente sostituire gli argomenti del primo comando set con qualsiasi combinazione di quelle lettere per ottenere ancora un risultato corretto! Quindi, questo ci dà 11 * 10 * 9 * 8 * 7 = 55440 soluzioni, ognuna di quelle lunghe 106 byte.

— Yoann
fonte

1

Il mio primo pensiero quando ho letto la sfida è stato "bisogna usare il figlet per risolvere questo problema"

— FliiFe

6

05AB1E , 102 90 89 69 byte (EOIXC)

•Cv¶ÉH&9;´ß{ø‰¿šq3d$µ_©Û¶«K>Ò±sÒ9ÍÊC4ÊÚúNÏŒº9¨gÚSÞ•34B2ð:2ôvy`×}J3äû»

Provalo online!

Uscita (230 byte):

EEEEE      OOOO     IIIII     X   X      CCCC
E         O    O      I        X X      C    
EEEE      O    O      I         X       C    
E         O    O      I        X X      C    
EEEEE      OOOO     IIIII     X   X      CCCC

69/230 = 70% di compressione

Spiegazione:

La teoria era quella di scegliere lettere simmetriche verticalmente, quindi codificare le prime 3 righe e palindromizzarle. Fondamentalmente, ho codificato come {#} di {Letter} in coppie di 2 byte. Sono sicuro che c'è un modo migliore per farlo.

•Cv¶ÉH&9;´ß{ø‰¿šq3d$µ_©Û¶«K>Ò±sÒ9ÍÊC4ÊÚîòvÅrè‘¾)jM•34B
                    <decodes to>
"E5 6O4 5I5 5X1 3X1 6C4E1 9O1 4O1 6I1 8X1 1X1 6C1 4E4 6O1 4O1 6I1 9X1 7C1 4"

2ô            # Split into encoded pairs.
  vy   }      # Loop through each letter and number pair.
    `×        # Add the letter X number of times.
       J      # Join together.
        3ä    # Split into 3 parts length.
          û   # Palindromize.
           »  # Print separated by newlines.

-20 byte grazie a Emigna, sarò in chat per fare presto alcune domande;).

— Urna di polpo magico
fonte

1

È possibile salvare 19 byte sostituendo la stringa con •Cv¶ÉH&9;´ß{ø‰¿šq3d$µ_©Û¶«K>Ò±sÒ9ÍÊC4ÊÚîòvÅrè‘¾)jM•34B2ð:. Salta nella chat 05AB1E se hai domande sulla codifica.

— Emigna,

1

Inoltre, 45ôpuò essere 3ä.

— Emigna,

@Emigna Anon è simmetrica verticalmente, e nemmeno lo è F. Indovinando che una volta che inizi a utilizzare Go superiore, ciò rovinerà ciò di cui stai parlando, giusto? Inoltre, con la mia metodologia di compressione, volevo evitare lettere che presentavano più di 1 occorrenza per riga. Se vuoi golf quella soluzione e battermi, darei il benvenuto nell'esempio :).

— Magic Octopus Urn

C'è una 0nel O(fila centrale, lato destro)

— ETHproductions

1

•Cv¶ÉH&9;´ß{ø‰¿šq3d$µ_©Û¶«K>Ò±sÒ9ÍÊC4ÊÚúNÏŒº9¨gÚSÞ•corregge lo Ostesso conteggio byte.

— Emigna,

5

JavaScript ES6, 168 byte, CHAMP

Possiamo smettere di cercare ragazzi, abbiamo CHAMPqui

f=_=>
` C3cHaHdA2dMaMcP3
CgHaHcAaAcMM MMcPaP
CgH4cA4cM M McP3
CgHaHcAaAcMaMcP
 C3cHaHcAaAcMaMcP`.replace(/[a-z\d]/g,(a,i,c)=>+a?c[i-1].repeat(a):' '.repeat(parseInt(a,36)-7))

a.innerHTML = f()

<pre id=a>

Espandi frammento

— Bassdrop Cumberwubwubwub
fonte

5

Brainf *** 512 411 byte

Meglio ripetere:

Questo fa un lavoro migliore nell'ottimizzare il nastro, sacrificando i caratteri di installazione per i caratteri di stampa. Il nastro in questo sembra'C' 'E' ' ' 'F' 'I' 'L' '\n' , migliorando l'efficienza. Ho scelto questi perché mancano di spazi interni, facendo in modo che non debbano andare avanti e indietro tra personaggio e spazio più del necessario

++++++++[>+++++++++>+++++++++>++++>+++++++++>+++++++++>+++++++++>+<<<<<<<-]>----->--->>-->+>++++>++<<<<.<<....>>.....<.....>.....>.....<.....>>.....<<.....>>>.>.<<<<<<.>>.........<.>.........>.<...........>>.<<.......>>>.>.<<<<<<.>>.........<....>......>....<........>>.<<.......>>>.>.<<<<<<.>>.........<.>.........>.<...........>>.<<.......>>>.>.<<<<.<<....>>.....<.....>.....>.<.........>>.....<<.....>>>.....

Se vuoi leggere cosa sta facendo:

Set the tape with 67,69,32,70,73,76,10
++++++++[>+++++++++>+++++++++>++++>+++++++++>+++++++++>+++++++++>+<<<<<<<-]>----->--->>-->+>++++>++<<<< 
.<<....>>.....<.....>.....>.....<.....>>.....<<.....>>>.>.<<<<<< First Line
.>>.........<.>.........>.<...........>>.<<.......>>>.>.<<<<<< Second Line
.>>.........<....>......>....<........>>.<<.......>>>.>.<<<<<< Third Line
.>>.........<.>.........>.<...........>>.<<.......>>>.>.<<<< Fourth Line
.<<....>>.....<.....>.....>.<.........>>.....<<.....>>>..... Fifth Line

Produzione:

 CCCC     EEEEE     FFFFF     IIIII     L
C         E         F           I       L
C         EEEE      FFFF        I       L
C         E         F           I       L
 CCCC     EEEEE     F         IIIII     LLLLL

Precedente presentazione:

++++++++[>++++<-]>[>++>++>++>++>++>+<<<<<<-]>+>++>+++>++++>+++++>>++++++++++<.<<<<<...>>>>>......<<<<....>>>>.......<<<....>>>.....<<....>>......<.....>>.<<<<<<.>>>>>...<<<<<.>>>>>.....<<<<.>>>>...<<<<.>>>>.....<<<.>>>.........<<.>>...<<.>>.....<.>>.<<<<<<.....>>>>>.....<<<<....>>>>......<<<.>>>.........<<.>>...<<.>>.....<....>>.<<<<<<.>>>>>...<<<<<.>>>>>.....<<<<.>>>>...<<<<.>>>>.....<<<.>>>.........<<.>>...<<.>>.....<.>>.<<<<<<.>>>>>...<<<<<.>>>>>.....<<<<....>>>>.......<<<....>>>.....<<....>>......<.....

Ho scelto di utilizzare ABCDE perché rende molto più semplice l'impostazione del nastro per l'output, ma il tempo e i caratteri che ho perso nel passare dalla lettera a "" per tutto lo spazio negativo all'interno di A, B e D e il posizionamento di la fine alla fine del nastro mi ha ucciso, credo.

Ho finito con un nastro che aveva i valori 0 0 'A' 'B' 'C' 'D' 'E' ' ' \ne quindi l'output da lì

++++++++[>++++<-]>[>++>++>++>++>++>+<<<<<<-]>+>++>+++>++++>+++++>>++++++++++     This all sets up the tape as 0 0 A B C D E ' ' '\n'
<.<<<<<...>>>>>......<<<<....>>>>.......<<<....>>>.....<<....>>......<.....>>.<<<<<< First Line
.>>>>>...<<<<<.>>>>>.....<<<<.>>>>...<<<<.>>>>.....<<<.>>>.........<<.>>...<<.>>.....<.>>.<<<<<< Second Line
.....>>>>>.....<<<<....>>>>......<<<.>>>.........<<.>>...<<.>>.....<....>>.<<<<<< Third Line
.>>>>>...<<<<<.>>>>>.....<<<<.>>>>...<<<<.>>>>.....<<<.>>>.........<<.>>...<<.>>.....<.>>.<<<<<< Fourth Line
.>>>>>...<<<<<.>>>>>.....<<<<....>>>>.......<<<....>>>.....<<....>>......<..... Last Line

Produzione:

 AAA      BBBB       CCCC     DDDD      EEEEE
A   A     B   B     C         D   D     E
AAAAA     BBBB      C         D   D     EEEE
A   A     B   B     C         D   D     E
A   A     BBBB       CCCC     DDDD      EEEEE

— bioweasel
fonte

È possibile utilizzare [<]>in 3 occasioni per salvare 6 byte.

— Jo King,

5

Vim, 116 byte 99 byte

elitc

Giocato a meno di 100 con l'aiuto di @DrMcMoylex.

9i59Yo191919171
E L I T CPqqjx:%s/\d/\=repeat('"',submatch(0))
q8@q3bi  Y7w.PP4rE{wl4r 22wl.2x

Questo contiene caratteri non stampabili, quindi li ho aggiunti in basso (stile Vim), così puoi vederli.

9i5^[9^AYo191919171
E L I T C^[Pqqjx:%s/\d/\=repeat('^R"',submatch(0))
q8@q3bi  ^[Y7w.PP4rE{wl4r 22wl.2x

TryItOnline!

In pratica utilizza la stessa decodifica di lunghezza della risposta della gelatina. Ho usato lettere in cui potrei (si spera) ripetere la parte superiore in fondo, e le medie sarebbero tutte uguali. Dopo aver creato le parti superiori, inferiori e centrali, modifico i caratteri per renderli corretti:

Aggiungi due spazi all'I (più su quello sotto)
Aggiungi due spazi alla T
Aggiungi la barra della E
Rimuovi la parte superiore della L
Rimuovere la parte inferiore della T (ed eliminare i 2 spazi)

Devo aggiungere due spazi all'I, perché non ho permesso numeri a due cifre (quindi non avrei bisogno di un separatore. Questo porta a una corsa di 9 spazi dove ho bisogno di 11.

— nmjcman101
fonte

Benvenuto in PPCG, bella risposta :).

— Magic Octopus Urn

Stavo quasi per chiedere una risposta da Vim.

— Zoltán Schmidt,

2

Ho sempre votato Vim. :) Alcuni miglioramenti che vedo. 1) non è necessaria la barra finale sul comando sostitutivo. 2) Alcuni sinonimi utili: Yinvece di Vy, FIanziché ?I<cr>, {anziché gg, wanziché fl. 3) Se si utilizza rinvece di R, è possibile rimuovere il <esc>.

— DJMcMayhem

5

MATL , 49 byte

5:lyI&(g84*t0*ytP+g73*yy!qy5XyPl5LY(90*yy!P12-&hc

Provalo online!

Questo produce le lettere TIHZN:

TTTTT     IIIII     H   H     ZZZZZ     N   N
  T         I       H   H        Z      NN  N
  T         I       HHHHH       Z       N N N
  T         I       H   H      Z        N  NN
  T       IIIII     H   H     ZZZZZ     N   N

Spiegazione

Tè relativamente facile da costruire da zero. Ipuò essere ottenuto essenzialmente come Tpiù la sua riflessione verticale. Hè Itrasposto. Nviene Ztrasposto e riflesso verticalmente.

5:        % Push [1 2 3 4 5]
lyI&(     % Write [1 ;2; 3; 4 ;5] in the third column, filling with zeros.
          % This gives the shape of the 'T'
g84*      % Change nonzeros into 84 (ASCII for 'T'). Zeros will be displayed
          % as spaces
t0*       % Duplicate and multiply by zeros. This gives the separator
y         % Duplicate from below: pushes the 'T' again
tP+       % Duplicate, flip vertically, add. Gives the shape of the 'I'
g73*      % Change nonzeros into 73 (ASCII for 'I')
yy        % Duplicate separator and 'I' array
!         % Transpose. Gives the shape of the 'H'
q         % Subtract 1. Transformss 73 into 72 (ASCII for 'H'), and 0 into -1,
          % which will later be changed back into 0 when converting to char
y         % Duplicate separator
5XyP      % Size-5 identity matrix flipped vertically: gives slash of the 'Z'
l5LY(     % Fill first and last rows with ones. Gives the shape of the 'Z'
90*       % Multiply by 90 (ASCII for 'Z')
yy        % Duplicate separator and 'Z' array
!P        % Transpose and flip vertically. Gives shape of the 'N'
12-       % Subtract 12 to yield ASCII code for 'N'. 0 is converted to -12
&h        % Concatenate the nine arrays horizontally
c         % Convert to char. Implicitly display

— Luis Mendo
fonte

4

V , 62 , 53 byte

iC±  I· D³ Dµ O³ O¸ Z3ñYp$XñS ´Cµ µIµ ´D· ³O¶ µZYHP

Provalo online!

Questo produce C I D O Z:

 CCCC     IIIII     DDDD       OOO      ZZZZZ
C           I       D   D     O   O        Z
C           I       D   D     O   O       Z
C           I       D   D     O   O      Z
 CCCC     IIIII     DDDD       OOO      ZZZZZ

— DJMcMayhem
fonte

3

Perl, 109 byte (ABCDE)

Nota : contiene caratteri non stampabili, scappati per facilità di test qui, xxddump qui sotto.

$_="\x0e\x1e\x0f\x1e\x1f
\x11\x11\x10\x11\x10
\x1f\x1e\x10\x11\x1e
\x11\x11\x10\x11\x10
\x11\x1e\x0f\x1e\x1f";s!.!(eval'(sprintf"%5b",ord$&)=~y/01/ '.(A..E)[$i++%5].'/r').$"x5!ge;print

Memorizza la rappresentazione binaria delle posizioni delle lettere come numero, quindi scompatta in binario, sostituendo 0s con spazi e1 s con la lettera corrispondente, usando una ricerca. Memorizzare le rappresentazioni delle lettere è abbastanza facile, ma sostituirle è risultato più complicato di quanto sperassi. Sono sicuro che ci sono modi migliori per farlo, quindi potrei continuare a giocarci.

Per ricreare il file, esegui xxd -r > favourite-letter.pl, incolla in basso e premi Ctrl+ D:

0000000: 245f 3d22 0e1e 0f1e 1f0a 1111 1011 100a  $_="............
0000010: 1f1e 1011 1e0a 1111 1011 100a 111e 0f1e  ................
0000020: 1f22 3b73 212e 2128 6576 616c 2728 7370  .";s!.!(eval'(sp
0000030: 7269 6e74 6622 2535 6222 2c6f 7264 2426  rintf"%5b",ord$&
0000040: 293d 7e79 2f30 312f 2027 2e28 412e 2e45  )=~y/01/ '.(A..E
0000050: 295b 2469 2b2b 2535 5d2e 272f 7227 292e  )[$i++%5].'/r').
0000060: 2422 7835 2167 653b 7072 696e 74         $"x5!ge;print

uso

perl favourite-letter.pl
 AAA      BBBB       CCCC     DDDD      EEEEE     
A   A     B   B     C         D   D     E         
AAAAA     BBBB      C         D   D     EEEE      
A   A     B   B     C         D   D     E         
A   A     BBBB       CCCC     DDDD      EEEEE

— Dom Hastings
fonte

3

Python 2, 124 byte

d,i,o,c,l,s,n='DIOCL \n'
T=d*4+s*6+i*5+s*6+o*3+s*7+c*4+s*5+l
M=d+s*3+d+s*7+i+s*7+o+s*3+o+s*5+c+s*9+l+n
print T+n,M,M,M,T+l*3

Simile alla mia altra risposta , ma con scelte di lettere migliori. Emette questo:

DDDD      IIIII      OOO       CCCC     L
D   D       I       O   O     C         L
D   D       I       O   O     C         L
D   D       I       O   O     C         L
DDDD      IIIII      OOO       CCCC     LLLL

— nedla2004
fonte

3

Befunge, 120 byte (CKYTF)

fonte

#&49+14489+56*1449135*44711425*:12p9138*7+:89+:56*55*v_@
-1g05$$_\#!:2#-%#16#\0#/g#20#,g#+*8#4<80\9*2p06%5p05:<^:,g2!%5:

Produzione

  CCCC     K   K     Y   Y     TTTTT     FFFFF
 C         K  K       Y Y        T       F
 C         KKK         Y         T       FFFF
 C         K  K        Y         T       F
  CCCC     K   K       Y         T       F

Provalo online!

Nel caso in cui sia importante, dovrei sottolineare che il mio output ha uno spazio iniziale su ogni riga. Le regole non lo proibivano esplicitamente, quindi spero che vada bene. In caso contrario, ti preghiamo di considerare questa voce come non competitiva.

Spiegazione

Le lettere della parola sono codificate come una semplice sequenza di 25 numeri interi, ciascuno dei quali è una rappresentazione binaria di 5 pixel. Poiché Befunge richiede di eseguire un calcolo per creare un'istanza di un numero intero maggiore di 9, le lettere sono state scelte in modo da ridurre al minimo il numero di calcoli richiesti e ordinate in modo che i potenziali valori ripetuti possano essere duplicati anziché ricalcolati.

Dobbiamo anche memorizzare il valore ASCII di ogni lettera, offset di 32, in un array che è indicizzato dal modulo 5 di un indice in decremento (quindi va 0 4 3 2 1 ...). Il motivo della compensazione per 32 è quindi che il valore può essere moltiplicato per un bit di pixel (1 o 0) e quindi aggiunto a 32 per produrre uno spazio o il carattere richiesto.

Questa matrice di valori di lettere è memorizzata nei primi 5 byte del codice, quindi è di facile accesso. Ciò influenzò quindi anche la scelta delle lettere, poiché quei valori dovevano essere significativi quando interpretati come una sequenza di codici. Questa è la sequenza #&49+. I #salti sopra &e il 49+giusto spinge 13 nello stack che viene successivamente ignorato.

— James Holderness
fonte

Stai chiedendo un input intero con il &, ma il tuo programma in realtà non accetta input ... cosa sta succedendo?

— Brian Gradin

Quel personaggio è saltato da '#'

— 12Me21

@ 12Me21 Ho spiegato il ragionamento dietro quello nell'ultimo paragrafo.

— James Holderness,

3

Rubino, 110 107 102 byte (DOCIL)

puts a=?D*4+(t=' '*7)+?O*3+t+?C*4+(s=' '*5)+?I*5+s+?L,['D   D'+s+'O   O'+s+?C+' '*11+?I+t+?L]*3,a+?L*4

stampe

DDDD       OOO       CCCC     IIIII     L
D   D     O   O     C           I       L
D   D     O   O     C           I       L
D   D     O   O     C           I       L
DDDD       OOO       CCCC     IIIII     LLLLL

EDIT: salvato alcuni caratteri evitando joine spostando le cose

— Lee W.
fonte

3

Befunge-98 , 109 98 byte (FUNGE / ANY)

:5%!2>j#4_;\$&\#;\:0`!#@_:::'@/'@*-\'@/2%*' +,:'@/:2/-'@*-\1+:5%!2>j#4_;' 3k:4k,#;:55*%!2>j#4_;a,;

Provalo online!

Input (115 caratteri):

2022 1141 1134 935 2021 102 1141 1262 103 101 998 1141 1390 1639 997 102 1141 1646 1127 101 102 949 1134 935 2021 0

L'input è la versione intera di un numero binario con il formato in aaaaabbbbbbcui aaaaaè una mappa invertita del carattere da stampare (ad esempio, la seconda riga nella N è NN N, quindi la maschera è 10011), ebbbbbb è il carattere ASCII da stampare, meno 32 .

Ho anche creato un programma befunge-98 per creare i miei input:

4k~44p34p24p14p04p          v
+1.+-**244g4%5\**88_@#`0:&::<

Provalo online!

Uscita (255 caratteri):

FFFFF     U   U     N   N      GGG      EEEEE     
F         U   U     NN  N     G         E         
FFFF      U   U     N N N     G  GG     EEEE      
F         U   U     N  NN     G   G     E         
F          UUU      N   N      GGG      EEEEE

(255 - (115 + 98)) / 255 = compressione del 16%

Spiegazione:

:5%!2>j#4_;\$&\#;\:0`!#@_     Get input if it is available, else end program
:::'@/'@*-\'@/2%*' +,         Output the current input character (or a space,
                              if the mask dictates so)
:'@/:2/-'@*-                  Throw away current mask bit
\1+                           Swap loop iterator to top of stack, increment it
:5%!2>j#4_;' *3k:4k,#;        If iterator % 5 == 0, print five spaces
:55*%!2>j#4_;a,;              If iterator % 25 == 0, print newline character

Questo è probabilmente piuttosto giocabile a golf; Ho passato appena il tempo a pensare a potenziali riduzioni.

Teoricamente questo può stampare qualsiasi sequenza di arte ascii 5x5.

Grazie a James Holderness per avermi aiutato a uscire da tre cifre!

— Brian Gradin
fonte

Per approfondire l'idea, 48*può essere sostituito con ' (dato che dopo tutto è 98) e 88*può essere sostituito con '@. Grazie per avermi aiutato a uscire di tre cifre!

— Brian Gradin

3

C #, 290 279 267 265 byte

Modifica: salvato 12 byte grazie a @milk! E altri 2 grazie a @TheLethalCoder

golfed:

void F(){string g="     ",h="H   H",A="A   A",B=h+"|"+A;Func<string,string>j=a=>a.Replace("|",g)+"\n";Console.Write(j(" SSSS|"+h+"| AAA |RRRR |PPPP")+j("S    |"+B+"|R   R|P   P")+j(" SSS |HHHHH|AAAAA|RRRR |PPPP")+j("    S|"+B+"|R  R |P")+j("SSSS |"+B+"|R   R|P"));}

Ungolfed:

public void F()
{
  string g = "     ", h = "H   H", A = "A   A", B = h + "|" + A;
  Func<string, string> j = a => a.Replace("|", g) + "\n";
  Console.Write(j(" SSSS|" + h + "| AAA |RRRR |PPPP") +
  j("S    |" + B + "|R   R|P   P") +
  j(" SSS |HHHHH|AAAAA|RRRR |PPPP") +
  j("    S|" + B + "|R  R |P") +
  j("SSSS |" + B + "|R   R|P"));
}

Uscite:

 SSSS     H   H      AAA      RRRR      PPPP
S         H   H     A   A     R   R     P   P
 SSS      HHHHH     AAAAA     RRRR      PPPP
    S     H   H     A   A     R  R      P
SSSS      H   H     A   A     R   R     P

— Pete Arden
fonte

C'è stato un secondo in cui ho pensato che il tuo codice C fosse lungo 290279 byte.

— Steven H.

1

@StevenH. Sembra così giocare a golf in C # :)

— Pete Arden,

-12 byte se si definisce la funzione locale in questo modoFunc<string,string>j=a=>a.Replace("|",g)+"\r\n";

— latte

@ latte freddo, grazie! :)

— Pete Arden,

Hai bisogno di \ r in \ r \ n?

— Salverebbe

3

Stax , 33 byte "BCDEO"

┌☼&.àτ▲█╟;c♦▌ΩÅ╡≤♫¿(┌▲▲≡3*╤J s*è«

Esegui ed esegui il debug

Ho scelto le lettere

avere simmetria verticale
le cui tre colonne centrali sono identiche

Queste proprietà indicano che ogni lettera può essere rappresentata da una griglia 3x3. Ecco le 9 regioni, rappresentate da cifre.

Considera la lettera "B". Può essere rappresentato da 3 cifre ottali:656 . Ogni cifra contiene tre bit, che controllano quali regioni sono abilitate per quella lettera. Questa tecnica funziona anche per "CDEO".

Disimballato, non modificato e commentato, il programma si presenta così.

"!^*14>G2eo"!   crammed integer literal             [63672, 54545, 64565]
|p              palindromize                        [63672, 54545, 64565, 54545, 63672]
m               for each, run this and output...    
  E             extract decimal digits to array     [6, 3, 6, 7, 2]
  `)"+0`        compressed string literal           "BCDEO"
  \             zip arrays                          [[6, 66], [3, 67], [6, 68], [7, 69], [2, 79]]
  {             map array using block               
    E           explode array                       6, 66
    Z\          tuck a zero under, and make pair    6, [0, 66]
    :B          custom base convert                 [66, 66, 0] 
    3)          pad to length 3                     [66, 66, 0]
    3O\         tuck a one under a 3 and pair       [66, 66, 0], [1, 3]
    :B          repeat elements corresponding times [66, 66, 66, 66, 0]
    A(          pad right to length 10              [66, 66, 66, 66, 0, 0, 0, 0, 0, 0]
  m

Esegui questo

— ricorsivo
fonte

2

Python 3, 234 228 227 166 byte (CLOUD):

import base64,gzip;b=b'ABzY86gn$d0{>HR1_A{T@KJyRe}8`nBNU1i6kLFS%Nec$q1YdaQ51tPO;sx(oDBkK&Q=Hwg(wC)8vxUXJX_-c000';print(gzip.decompress(base64.b85decode(b)).decode())

stampe:

 CCCC     L          OOO      U   U     DDDD
C         L         O   O     U   U     D   D
C         L         O   O     U   U     D   D
C         L         O   O     U   U     D   D
 CCCC     LLLLL      OOO       UUU      DDDD

— L3viathan
fonte

2

Python 3, 178 byte

e,f,i,t,h,s='EFITH '
p=print
S=s*5
D=i+s*9+t+s*7
A=e*5+S
F=S+i*5+S
B=e+s*9+f+s*11+D+h+s*3+h
C=h+s*3+h
p(A+f*5+F+t*5+S+C)
p(B)
p(e*4+s*6+f*4+s*8+D+h*5)
p(B)
p(A+f+s*4+F,s+t+s*7+C)

Non vincerà, ma non utilizza alcuna compressione. Rende questo:

EEEEE     FFFFF     IIIII     TTTTT     H   H
E         F           I         T       H   H
EEEE      FFFF        I         T       HHHHH
E         F           I         T       H   H
EEEEE     F         IIIII       T       H   H

Qualsiasi aiuto è il benvenuto, probabilmente ho perso qualcosa. Non ho usato Python 2 perché non puoi farlo p=print, e questo fa risparmiare 17 byte. Provalo su repl.it.

— nedla2004
fonte

2

Che succede con quella F?

— Limone distruttibile

@DestructibleWatermelon Non so come l'ho perso, ma ora è stato risolto.

— nedla2004,

Golfato al di sotto delle dimensioni originali: 160 byte, Python 2

— Calcolatrice

Invece di usare p=print, puoi usare una singola printistruzione con l'argomento kw sep='\n'.

— Luca Citi,

2

Rubino, 101 byte (TIFLE)

"o@h@u".bytes{|i|k=3+i%2;puts "%-10s"*5%"TIFLE".chars.map{|j|i/=2;(i/16>i%2*3?'  ':'')+j+j*k*(i%2)}}

TTTTT     IIIII     FFFFF     L         EEEEE
  T         I       F         L         E
  T         I       FFFF      L         EEEE
  T         I       F         L         E
  T       IIIII     F         LLLLL     EEEEE

Ho scelto lettere che richiedevano un singolo blocco di lettere (1,4 o 5 lettere lunghe) su ogni riga. F, L ed E sono giustificati a sinistra, ma T e I richiedono spazi iniziali in cui è stampata una singola lettera (parte verticale). Il codice per aggiungere questi spazi sembra che potrebbe essere migliorato.

ungolfed

"o@h@u".bytes{|i|               #for each byte (64 always set, 32...2 bits set for horiz bar, 1 bit=length of bar)
   k=3+i%2                      #decode least sig. bit for no of chars printed if a 1 is found
   puts "%-10s"*5%              #puts "%-10s%-10s%-10s%-10s%-10s" format string (expects array of subsitutes)
     "TIFLE".chars.map{|j|      #for each letter 
        i/=2                    #halve i
        (i/16>i%2*3?'  ':'')+   #if i large enough and i%2 zero, add leading space (or T and I)
        j+j*k*(i%2)             #print the letter once, then additional letters if bar required.
     }
}

— Level River St
fonte

2

C 176 byte

Se sono consentiti ints impliciti, è possibile tagliare altri 8 byte.

#define C ,//11 bytes
#define R(r)r r r r r//21 bytes
T(int l){int c=324;printf(R(R("%c")R(" "))"\n" R(R(C(++c,l>>=1)&1?c/5:32)));}//77 bytes
f(){T(67010460);T(34702434);T(66160574);T(34702434);T(67010466);}//65 bytes

Uscita: EDCBA

EEEEE     DDDD       CCCC     BBBB       AAA      
E         D   D     C         B   B     A   A     
EEEEE     D   D     C         BBBB      AAAAA     
E         D   D     C         B   B     A   A     
EEEEE     DDDD       CCCC     BBBB      A   A

Come funziona: la macro R ripete solo un pezzo di codice 5 volte. Data la frequenza con cui i cinque appaiono in questo problema, molto utile. Ora: ecco cosa fa T (int). T prende un numero intero e lo usa come un campo di bit per determinare dove stampare le lettere e dove stampare gli spazi bianchi. Ad esempio, se dato T(0b11111111100111111110011100), il risultato sarà: EEEEE DDDD CCCC BBBB AAA. Conta alla rovescia progressivamente su quale lettera stampa. Prima stampa E, quindi D, quindi C, quindi B, quindi A. Chiamando f () stamperà l'intera cosa.

— J. Antonio Perez
fonte

2

Lotto, 135 byte (DOCILe)

@set b=     
@set s=@echo DDDD%b%  OOO%b%  CCC%b% IIIII%b%L
@set t=@echo D   D%b%O   O%b%C%b%%b% I%b%  L
%s%
%t%
%t%
%t%
%s%LLLL

Nota: la prima riga termina in 5 spazi.

— Neil
fonte

2

BASH, 95, 111 byte (EBASH)

golfed

base64 -d<<<4ADlADhdACLpBDSMnNdRTj0Ob2qBPVT3HkdMRZzZ3kL+yIb6mhkz06EM+KOspSDy2EBoUKKL6pfwNo0akV0zAA==|xz -dqFraw

Spiegazione

Base64 su flusso di byte LZMA non elaborato

dimostrazione

>base64 -d<<<4ADlADhdACLpBDSMnNdRTj0Ob2qBPVT3HkdMRZzZ3kL+yIb6mhkz06EM+KOspSDy2EBoUKKL6pfwNo0akV0zAA==|xz -dqFraw

EEEEE     BBBB       AAA       SSSS     H   H
E         B   B     A   A     S         H   H
EEEE      BBBB      AAAAA      SSS      HHHHH
E         B   B     A   A         S     H   H
EEEEE     BBBB      A   A     SSSS      H   H

Clausola di esclusione della responsabilità

Sì, sono ben consapevole che questo non è davvero portatile, ecco perché ho pagato un byte per sopprimere gli avvisi xz con -q nel primo caso> :)

— zeppelin
fonte

2

Python 2, 208 194 193 byte

Questo è il mio primo codice golf in assoluto;) Divertente da fare

for i in range(0,25,5):
 for c,p in {'M':18732593,'O':15255086,'N':18667121,'T':32641156,'Y':18157700}.items():
  print format(p,'025b')[i:i+5].replace('0',' ',).replace('1',c)+'   ',
 print

Produzione:

Y   Y    M   M    TTTTT     OOO     N   N
 Y Y     MM MM      T      O   O    NN  N
  Y      M M M      T      O   O    N N N
  Y      M   M      T      O   O    N  NN
  Y      M   M      T       OOO     N   N

L'uso di un dizionario distrugge l'ordinamento delle lettere, ma non era un requisito

— Pleiadiano
fonte

Potrebbe fare -4 se prendiamo lettere che non usano l'angolo in alto a sinistra. Ciò comporterebbe un numero di 24 bit (anziché 25) che occupa una cifra in meno in esadecimale.

— Pleiadiano

2

perl 94 byte.

Le prime 4 lettere (D , O, I, C) sono specificatamente scelti per avere le linee superiori e inferiori simili e quelli di mezzo simile. Non essendoci altre lettere simili, ho scelto la "L" per poter applicare lo stesso algoritmo e aggiungere il 4L mancante.

for(($a="D5 6O3 6I5 6C4 5L")."
","D 3D 5O 3O 7I 7C 9L
"x3,$a."4L
"){s/(.)(\d)/$1x$2/eg;print}

Ho salvato alcuni byte extra sostituendo \nil codice con una nuova riga reale.

Risultato:

DDDD       OOO      IIIII      CCCC     L
D   D     O   O       I       C         L
D   D     O   O       I       C         L
D   D     O   O       I       C         L
DDDD       OOO      IIIII      CCCC     LLLLL

— Adamo
fonte

5 lettere preferite

Regole aggiuntive:

Esempi:

Gelatina , 41 byte

LICTE

Idea

Il codice

Carbone , 51 49 byte (ECXKI)

PowerShell v2 +, 138 128 114 112 106 105 byte (LICTD)

JavaScript, 110 109 byte (CLOUD)

ES6 (Javascript), 194, 181 byte (IGOLF / ANY)

PHP, 107 104 102 94 86 byte

05AB1E , 44 byte

JavaScript (ES6), 96 byte (DIOCL)

Test snippet

Bash + coreutils con figlet, 55440 soluzioni, 112 106 byte ciascuno

05AB1E , 102 90 89 69 byte (EOIXC)

Uscita (230 byte):

Spiegazione:

JavaScript ES6, 168 byte, CHAMP

Brainf *** 512 411 byte

Vim, 116 byte 99 byte

elitc

MATL , 49 byte

Spiegazione

V , 62 , 53 byte

Perl, 109 byte (ABCDE)

uso

Python 2, 124 byte

Befunge, 120 byte (CKYTF)

Rubino, 110 107 102 byte (DOCIL)

Befunge-98 , 109 98 byte (FUNGE / ANY)

Input (115 caratteri):

Uscita (255 caratteri):

Spiegazione:

C #, 290 279 267 265 byte

Stax , 33 byte "BCDEO"

Python 3, 234 228 227 166 byte (CLOUD):

Python 3, 178 byte

Rubino, 101 byte (TIFLE)

C 176 byte

Lotto, 135 byte (DOCILe)

BASH, 95, 111 byte (EBASH)

Python 2, 208 194 193 byte

perl 94 byte.