Die Herausforderung ist eigentlich extrem einfach. Wählen Sie 5 verschiedene Buchstaben (Sie können einfach die 5 auswählen, mit denen Sie den kürzesten Code erhalten, wenn Sie möchten) und geben Sie sie auf der Konsole aus. Der Clou ist jedoch, dass sie aus der folgenden Liste stammen müssen:

 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

Zusätzliche Regeln:

• 5 gleiche Buchstaben sind nicht erlaubt, keine Wiederholungswahlen.
• Jeder Buchstabe muss sein eigenes Großbuchstaben als ASCII-Zeichen verwenden, um ihn zu zeichnen.
• Jede Buchstabenausgabe muss in der "gleichen Zeile" stehen und 5 Leerzeichen zwischen den Buchstaben enthalten.
• Sie können 5 beliebige Buchstaben auswählen. Auf diese Weise können Sie Code wiederverwenden und die Anzahl der Bytes verringern. Es ist Teil der Herausforderung, herauszufinden, mit welchen Buchstaben Sie dies am effizientesten tun können.
• Leerzeichen sind akzeptabel.
• Eine einzelne abschließende Zeile ist zulässig, jedoch nicht mehr als eine abschließende Zeile.
• Dies ist Code-Golf, die niedrigste Anzahl an Bytes gewinnt.

Beispiele:

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    

VERRÜCKT

 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  

Haben Sie keine Angst, jedes Mal mehr als eine Antwort mit unterschiedlichen Buchstaben oder Strategien einzureichen. Dies kann auf verschiedene Arten erreicht werden.

Jelly , 41 Bytes

LICTE

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

TryItOnline!

Idee

Verwenden Sie eine Lauflängendekodierung mit Buchstaben, deren Mitte so ähnlich wie möglich ist, wobei nur eine Lauflänge für jeden "Pixelwert" pro Zeile und Buchstabe verwendet wird.

Setzen Sie einen flachen Start wie "L", um unterschiedliche Lauflängendecodierungswerte für die Zeilen zu vermeiden.

Platzieren Sie den einen anderen Buchstaben (konnte 5 nicht finden) der drei mittleren Reihen am Ende, damit der kleinste Unterschied rechnerisch addiert werden kann.

Ausgabe gewünscht; die Lauflängen; und diese von Basis 11 konvertiert:

                                                  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

Die drei Werte 399633415, 431646160und 1179122455in der Basis 250sind als Jelly - Codepage Indizes dann ðƁ ƥ, ȷɓSɠund JrŀṘdie verwendet werden , um die Lauflängeninformation zu verkapseln.

Der Code

“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

Kohle , 51 49 Bytes (ECXKI)

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

Ausgänge

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

Probieren Sie es online!

Zeichnet mit vertikal symmetrischen Zeichen die oberen Hälften und reflektiert sie dann. Die meisten davon verwenden Polygon ( Ｇ) und PolygonHollow ( ＧＨ), um eine Reihe von verbundenen Liniensegmenten mit einem bestimmten Zeichen zu zeichnen. Ikann einfacher mit MultiPrint ( Ｐ) durchgeführt werden, wobei Tals Richtung verwendet wird.

Hinweis: PolygonHollow zeichnet nur die angegebenen Segmente, ohne das Polygon zu vervollständigen oder zu füllen. Das Polygon wird vervollständigt und ausgefüllt (nicht das, was wir wollen), wenn das Polygon mit einer einfachen Linie in einer der acht Himmelsrichtungen oder zwischen den Himmelsrichtungen vervollständigt werden kann. Ansonsten verhält es sich wie PolygonHollow, mit einer Einsparung von einem Byte.

Die Reihenfolge der Zeichen wurde so gewählt, dass nur horizontale Bewegungen vom Endpunkt eines Zeichens zum Anfang des nächsten Zeichens erforderlich sind. So verfährt der Cursor:

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,'     '

Die Idee ist, die Abstände zwischen den Buchstaben zu maximieren, damit wir wiederholte Komprimierungen erhalten können.

Leiht den Deduplizierungstrick für die mittlere Zeile aus Florents Antwort . Dank Ben Owen konnten 6 Byte durch die Verwendung der String-Multiplikation für die mittleren drei Zeilen und dank Matt ein zusätzliches Byte eingespart werden .

Die Ausgabe ist wie folgt bei 227 Bytes für eine 53,7% ige Reduzierung -

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

JavaScript, 110 bis 109 Byte (CLOUD)

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

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

Die Ausgabe beträgt 227 Bytes:

 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

ES6 (Javascript), 194181 Bytes (IGOLF / ANY)

Dieser ist lang und (noch) nicht wirklich optimiert. Er kann jedoch geändert werden, um eine bestimmte Nachricht zu drucken, indem nur die Bitmap-Daten geändert werden.

BEARBEITEN: Inneres Verkleinern durch Map ersetzt , Bitverschiebung zum Auffüllen verwenden

Golf gespielt

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

Demo

[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         

Theorie

Nimm einen Brief:

IIIII      
  I        
  I        
  I        
IIIII 

konvertiere es in eine binäre Matrix (Bitmap)

11111
00100
00100
00100
11111

Machen Sie dasselbe für die anderen 4 Buchstaben, scannen Sie eine Zeile, indem Sie jeweils die "oberen" 5 Bits entfernen

11111 01110 01110 10000 11111

in eine hexadezimale Zeichenfolge konvertieren (sollte base36 oder sogar druckbares ASCII verwenden)

0x1f73a1f

Wenden Sie den gleichen Algorithmus auf andere 4 Zeilen an, um die Bitmap zu erhalten.

In umgekehrter Reihenfolge rendern.

PHP, 107 104 102 94 86 Bytes

Ok, ich bin zuversichtlich, dass ich mit dieser Methode jetzt die kleinstmögliche Quelle habe. Ich habe ein Skript geschrieben, um jede mögliche Kombination von fünf Buchstaben zu generieren und dann zu gzipen. Es gibt zwei Lösungen, die für die kürzeste Komprimierung passen - LODIC und LDOIC. Ich gehe mit dem ersteren, weil es mehr Spaß macht, es zu sagen.

Quelle:

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

Ausgabe:

% 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

05AB1E , 44 Bytes

Dies war ein Spaß.
Ich habe das Gefühl, ich muss zurückkommen und es noch einmal versuchen, wenn ich Zeit habe.

Verwendet CP-1252- Codierung.
Inspiriert von der Antwort von carusocomputing .

ECOIH

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

Probieren Sie es online!

Erläuterung

‘ÓÑOIHH‘drückt die Saite "ECOOIHH".

SðýJ3×SVerbindet den String durch Leerzeichen, wiederholt ihn dreimal und konvertiert ihn in eine Liste.
Die resultierende Liste ist ['E', ' ', 'C', ' ', 'O', ' ', 'O', ' ', 'I', ' ', 'H', ' ', 'H', 'E', ' ', 'C', ' ', 'O', ' ', 'O', ' ', 'I', ' ', 'H', ' ', 'H', 'E', ' ', 'C', ' ', 'O', ' ', 'O', ' ', 'I', ' ', 'H', ' ', 'H'].

•Td<UÕ‘áÓ?¢tWvkÔÚ•drückt die Nummer 564631055513119191317171314619131717500.

S)ø Zippt die Liste und die Nummer zusammen.

ü×JFührt eine paarweise String-Wiederholung durch und verbindet sie miteinander.
Das Ergebnis ist die Zeichenfolge EEEEE CCCC OOO IIIII H HE C O O I H HEEEE C O O I HHHHH.

3äû»teilt das in 3 Teile auf, fügt das erste und zweite Stück in umgekehrter Reihenfolge hinzu und fügt sich durch Zeilenumbrüche zusammen.

JavaScript (ES6), 96 Byte (DIOCL)

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

Die Idee hier ist, nicht nur die mittleren drei Zeilen identisch zu machen, sondern auch die erste Zeile fast identisch mit der letzten. Da es nur 4 Buchstaben gibt, die perfekt zu dieser Beschreibung passen CDIO, List dies die nächstbeste Option, da nur 4 zusätzliche Zeichen am Ende der Zeichenfolge erforderlich sind.

Wie bei Florents Antwort ist dies ein Ausschnitt, der das Ergebnis zurückgibt. Fügen Sie 3 Bytes hinzu, wenn es eine Funktion sein muss.

Testschnipsel

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

Bash + Coreutils mit Figlet, 55440 Lösungen, 112 106 Bytes

 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

Ausgabe:

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

Hey, wir haben bereits ein Programm für ASCII-Kunst! Die Banner- Schriftart erledigt fast den Job, außer dass sie 7x7 Buchstaben ausgibt. Hmm, lass uns einfach die 3. und 5. Spalte und die 2. und 5. Zeile entfernen und sehen, was es gibt ...

Es stellt sich heraus, dass viele Buchstaben auf die erforderliche Weise ausgegeben werden, nämlich BDEFHJLPTU Z.

Es genügt, die Argumente des ersten gesetzten Befehls durch eine beliebige Kombination dieser Buchstaben zu ersetzen, um immer noch ein korrektes Ergebnis zu erhalten! Dies ergibt also 11 * 10 * 9 * 8 * 7 = 55440 Lösungen mit einer Länge von jeweils 106 Bytes.

05AB1E , 102 90 89 69 Byte (EOIXC)

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

Probieren Sie es online!

Ausgabe (230 Bytes):

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% Komprimierung

Erläuterung:

Die Theorie war, vertikal symmetrische Buchstaben auszuwählen, dann die ersten 3 Zeilen zu kodieren und sie zu palindromisieren. Grundsätzlich habe ich als {#} von {Letter} in 2-Byte-Paaren codiert. Ich bin sicher, es gibt einen besseren Weg, dies zu tun.

•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 bytes danke an emigna, ich werde bald im chat ein paar fragen stellen;).

JavaScript ES6, 168 Byte, CHAMP

Wir können aufhören, Leute zu suchen, wir haben einen CHAMPhier

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>

Brainf 512 411 Bytes

Besser wiederholen:

Dieser optimiert das Band besser, indem er Setup-Zeichen für das Drucken von Zeichen opfert. Das Band in diesem sieht so aus 'C' 'E' ' ' 'F' 'I' 'L' '\n', als würde es die Effizienz verbessern. Ich habe mich für diese entschieden, weil ihnen Innenräume fehlen, damit sie nicht mehr als nötig zwischen Charakter und Raum hin und her wechseln müssen

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

Wenn Sie lesen möchten, was es tut:

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

Ausgabe:

 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

Frühere Einreichung:

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

Ich entschied mich für ABCDE, weil es das Einrichten des Bandes für die Ausgabe sehr viel einfacher macht, aber die Zeit und die Zeichen, die ich verschwendet habe, um den ganzen negativen Raum innerhalb von A, B und D und die Platzierung von '' zu erreichen Die Endzeile am Ende des Bandes hat mich umgebracht, glaube ich.

Ich endete mit einem Band, das die Werte hatte 0 0 'A' 'B' 'C' 'D' 'E' ' ' \nund dann von dort ausgegeben wurde

++++++++[>++++<-]>[>++>++>++>++>++>+<<<<<<-]>+>++>+++>++++>+++++>>++++++++++     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

Ausgabe:

 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

Vim, 116 Bytes 99 Bytes

ELITC

Golfen unter 100 mit Hilfe von @DrMcMoylex.

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

Diese enthält nicht druckbare Zeichen, daher habe ich sie unten hinzugefügt (Vim-Stil), damit Sie sie sehen können.

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

TryItOnline!

Grundsätzlich wird die gleiche Lauflängendecodierung verwendet wie bei der Gelee-Antwort. Ich habe Buchstaben verwendet, bei denen ich (hoffentlich) das Obere auf dem Unteren wiederholen konnte, und die Mitten wären alle drei gleich. Sobald die Oberseiten, Unterseiten und Mitten erstellt sind, bearbeite ich die Zeichen, um sie zu korrigieren:

1. Füge zwei Leerzeichen zum I hinzu (mehr dazu unten)
2. Fügen Sie dem T zwei Leerzeichen hinzu
3. Fügen Sie den Balken des E hinzu
4. Entfernen Sie die Oberseite des L
5. Entferne den Boden des T (und lösche die 2 Felder)

Ich muss dem I zwei Leerzeichen hinzufügen, da ich keine zweistelligen Zahlen zulasse (daher würde ich kein Trennzeichen benötigen. Dies führt zu einem 9-Leerzeichen-Lauf, bei dem ich 11 benötige.

MATL , 49 Bytes

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

Probieren Sie es online!

Dies erzeugt die Buchstaben 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

Erläuterung

Tist relativ einfach von Grund auf neu zu bauen. Ikann im wesentlichen als TPlus seiner vertikalen Reflexion erhalten werden. Hwird Iumgesetzt. Nist Ztransponiert und vertikal reflektiert.

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

V , 62 , 53 Bytes

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

Probieren Sie es online!

Dies gibt aus 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

Perl, 109 Bytes (ABCDE)

Hinweis : Dies enthält nicht druckbare Zeichen, die zur Vereinfachung des Testens hier ausgeblendet xxdwerden.

$_="\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

Speichert die Binärdarstellung der Buchstabenpositionen als Zahl und entpackt sie dann in eine Binärdarstellung, wobei 0s durch Leerzeichen und 1s durch den entsprechenden Buchstaben ersetzt wird. Das Speichern der Buchstabenrepräsentationen ist recht einfach, aber das Ersetzen stellte sich als schwieriger heraus, als ich gehofft hatte. Ich bin mir sicher, dass es dafür bessere Möglichkeiten gibt, also könnte ich auch weiterhin damit spielen.

Um die Datei neu zu erstellen, führen Sie den folgenden Befehl aus xxd -r > favourite-letter.pl, fügen Sie ihn ein und drücken Sie 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

Verwendungszweck

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     

Python 2, 124 Bytes

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

Ähnlich wie meine andere Antwort , aber mit besseren Buchstabenauswahlmöglichkeiten. Gibt Folgendes aus:

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

Befunge, 120 Bytes (CKYTF)

Quelle

#&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:

Ausgabe

  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

Probieren Sie es online!

Falls es darauf ankommt, sollte ich darauf hinweisen, dass meine Ausgabe in jeder Zeile ein vorangestelltes Leerzeichen enthält. Die Regeln haben das nicht ausdrücklich verboten, also hoffe ich, dass das in Ordnung ist. Wenn nicht, betrachten Sie diesen Eintrag bitte als nicht konkurrierend.

Erläuterung

Die Buchstaben des Wortes werden als einfache Folge von 25 Ganzzahlen codiert, wobei jede Ganzzahl eine binäre Darstellung von 5 Pixeln ist. Da Sie bei Befunge eine Berechnung ausführen müssen, um eine ganze Zahl größer als 9 zu instanziieren, wurden die Buchstaben so ausgewählt, dass die Anzahl der erforderlichen Berechnungen auf ein Minimum reduziert und die Reihenfolge so festgelegt wird, dass potenzielle Wiederholungswerte dupliziert und nicht neu berechnet werden können.

Wir müssen auch den ASCII-Wert jedes Buchstabens, der um 32 versetzt ist, in einem Array speichern, das durch das Modulo 5 eines dekrementierenden Indexes indiziert wird (also 0 4 3 2 1 ...). Der Grund für das Versetzen um 32 ist, dass der Wert mit einem Pixelbit (1 oder 0) multipliziert und dann zu 32 addiert werden kann, um entweder ein Leerzeichen oder das erforderliche Zeichen zu erzeugen.

Dieses Array von Buchstabenwerten wird in den ersten 5 Bytes des Codes gespeichert, sodass ein einfacher Zugriff möglich ist. Dies wirkte sich dann auch auf die Auswahl der Buchstaben aus, da diese Werte bei der Interpretation als Codesequenz aussagekräftig sein mussten. Das ist die Reihenfolge #&49+. Der #springt über den &und der 49+drückt gerade 13 auf den Stapel, der anschließend ignoriert wird.

Ruby, 110 107 102 Bytes (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

Druckt

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

BEARBEITEN: Einige Zeichen wurden gespeichert, joinindem Dinge vermieden und verschoben wurden

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

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

Probieren Sie es online!

Eingabe (115 Zeichen):

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

Die Eingabe ist die ganzzahlige Version einer Binärzahl mit dem Format, aaaaabbbbbbbei dem aaaaaes sich um eine umgekehrte Zuordnung des zu druckenden Zeichens handelt (z. B. die zweite Zeile in N NN N, also die Maske 10011) und bbbbbbdas zu druckende ASCII-Zeichen minus 32 .

Ich habe auch ein befunge-98-Programm erstellt, um meine Eingaben zu erstellen:

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

Probieren Sie es online!

Ausgabe (255 Zeichen):

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 = 16% Komprimierung

Erläuterung:

: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

Das ist wahrscheinlich ziemlich golfen; Ich habe kaum über mögliche Reduzierungen nachgedacht.

Theoretisch kann damit jede Sequenz von 5 x 5 ASCII-Bildern gedruckt werden.

Vielen Dank an James Holderness, der mir geholfen hat, dreistellige Zahlen zu überwinden!

C #, 290 279 267 265 Bytes

Bearbeiten: 12 Bytes dank @milk gespeichert! Und 2 weitere dank @TheLethalCoder

Golf gespielt:

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

Ausgänge:

 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

Stax , 33 Bytes "BCDEO"

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

Führen Sie es aus und debuggen Sie es

Ich habe Buchstaben ausgewählt

• vertikale Symmetrie haben
• deren mittlere drei Spalten identisch sind

Diese Eigenschaften bedeuten, dass jeder Buchstabe durch ein 3x3-Raster dargestellt werden kann. Hier sind die 9 Regionen, dargestellt durch Ziffern.

12223
45556
78889
45556
12223

Betrachten Sie den Buchstaben "B". Es kann durch 3 Oktalziffern dargestellt werden: 656. Jede Ziffer enthält drei Bits, die steuern, welche Bereiche für diesen Buchstaben aktiviert sind. Diese Technik funktioniert auch bei "CDEO".

Entpackt, ungolfed und kommentiert sieht das Programm so aus.

"!^*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

Führen Sie dieses aus

Python 3, 234 228 227 166 Bytes (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())

Drucke:

 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

Python 3, 178 Bytes

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)

Gewinnt nicht, verwendet aber keine Komprimierung. Es macht das:

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

Jede Hilfe ist willkommen, ich habe wahrscheinlich etwas verpasst. Ich habe Python 2 nicht verwendet, weil Sie das nicht können p=print, und das spart 17 Bytes. Probieren Sie es auf repl.it.

Ruby, 101 Bytes (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

Ich suchte mir Buchstaben aus, für die in jeder Zeile ein einzelner Buchstabenblock (1,4 oder 5 Buchstaben) erforderlich war. F, L und E sind linksbündig, aber T und ich benötigen führende Leerzeichen, wenn ein einzelner Buchstabe (vertikaler Teil) gedruckt wird. Der Code zum Hinzufügen dieser Leerzeichen scheint verbessert werden zu können.

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

C 176 Bytes

Wenn implizite Ints zulässig sind, können weitere 8 Bytes abgeschnitten werden.

#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

Ausgabe: 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     

So funktioniert es: Das Makro R wiederholt einen Code nur fünfmal. Angesichts der Häufigkeit, mit der Fünfer in diesem Problem auftreten, sehr nützlich. Nun: Hier ist was T (int) macht. T nimmt eine ganze Zahl und verwendet sie als Bitfeld, um zu bestimmen, wo Buchstaben und Leerzeichen gedruckt werden sollen. Wenn angegeben Zum Beispiel T(0b11111111100111111110011100), wird es ausgegeben: EEEEE DDDD CCCC BBBB AAA. Es zählt nach und nach herunter, welcher Buchstabe gedruckt wird. Zuerst wird E, dann D, dann C, dann B und dann A ausgegeben. Wenn Sie f () aufrufen, wird das gesamte Objekt gedruckt.

Batch, 135 Bytes (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

Hinweis: Die erste Zeile endet in 5 Leerzeichen.

BASH, 95111 Bytes (EBASH)

Golf gespielt

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

Erläuterung

Base64 über rohen LZMA-Byte-Stream

Demo

>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

Haftungsausschluss

Ja, mir ist klar, dass dies nicht wirklich portabel ist. Deshalb habe ich ein Byte bezahlt, um die xz- Warnungen im ersten Fall mit -q zu unterdrücken > :)

Python 2, 208 194 193 Bytes

Dies ist mein allererster Code Golf;) Spaß zu machen

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

Ausgabe:

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

Die Verwendung eines Wörterbuchs zerstört die Sortierreihenfolge der Buchstaben, aber das war keine Voraussetzung

Perl 94 Bytes.

Die ersten 4 Buchstaben ( D, O, I, C) sind insbesondere die oberen und unteren Linien ähnlich, und die mittleren ähnliche so gewählt. Da es keinen ähnlichen Buchstaben gibt, habe ich das "L" gewählt, um den gleichen Algorithmus anwenden und die fehlenden 4L hinzufügen zu können.

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

Ich habe einige zusätzliche Bytes gespart, indem ich \nden Code durch eine echte neue Zeile ersetzt habe.

Ergebnis:

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