Le défi est extrêmement simple. Choisissez 5 lettres distinctes (vous pouvez simplement choisir les 5 qui vous permettent le code le plus court si vous le souhaitez) et envoyez-les à la console. Cependant, le problème est qu’ils doivent appartenir à la liste suivante:

 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

Règles supplémentaires:

• 5 lettres identiques ne sont pas autorisées, pas de choix répété.
• Chaque lettre doit utiliser sa capitale comme caractère ascii pour la dessiner.
• Chaque lettre doit être sur la "même ligne" et avoir 5 espaces entre chaque lettre.
• Vous pouvez choisir les 5 lettres de votre choix , cela vous permettra de réutiliser du code et de réduire le nombre d'octets. Déterminer quelles lettres vous permettront de le faire plus efficacement fait partie du défi.
• Les espaces de fuite sont acceptables.
• Une nouvelle ligne de fuite est acceptable, mais pas plus d’une nouvelle ligne.
• C'est le code-golf, le nombre d'octets le plus faible gagne.

Exemples:

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    

FOU

 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  

N'ayez pas peur de soumettre plus d'une réponse avec des lettres différentes ou des stratégies différentes à chaque fois, vous pouvez le faire de différentes manières.

Gelée , 41 octets

LICTE

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

TryItOnline!

Idée

Utilisez un décodage de longueur de cycle avec des lettres ayant le milieu le plus similaire possible avec seulement une longueur de cycle de chaque "valeur de pixel" par ligne et par lettre.

Mettez un début plat comme "L" pour éviter différentes valeurs de décodage de longueur d'exécution pour les lignes.

Placez la lettre différente (impossible à trouver 5) des trois rangées du milieu à la fin pour que la plus petite différence puisse être ajoutée arithmétiquement.

Sortie souhaitée; les longueurs de parcours; et ceux convertis de la 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

Les trois valeurs 399633415, 431646160et 1179122455dans la base 250sous forme d' indices page de code Jelly sont alors ðƁ ƥ, ȷɓSɠet JrŀṘqui peuvent être utilisées pour encapsuler les informations de longueur d'exécution.

Le 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

Charbon de bois , 51 49 octets (ECXKI)

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

Les sorties

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

Essayez-le en ligne!

En utilisant des caractères symétriques verticalement, dessine les moitiés supérieures puis se reflète. La plupart d'entre elles utilisent Polygon ( Ｇ) et PolygonHollow ( ＧＨ) pour dessiner une série de segments de ligne connectés avec un caractère particulier. Ipeut plus facilement être fait avec MultiPrint ( Ｐ), en utilisant Tcomme direction.

Remarque: PolygonHollow dessine simplement les segments spécifiés, sans terminer le polygone ni le remplir. Le polygone sera complété et rempli (pas ce que nous voulons) si le polygone peut être complété par une simple ligne dans l’une des huit directions cardinales ou intercardinales. Sinon, il se comporte comme PolygonHollow, pour une économie d'un octet.

L'ordre des caractères a été choisi pour ne nécessiter que des déplacements horizontaux du point d'extrémité au début du point suivant. Voici comment le curseur procède:

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

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

L'idée est de maximiser les espaces entre les lettres afin que nous puissions obtenir des compressions répétées.

Emprunte l'astuce de déduplication de la ligne du milieu à la réponse de Florent . Sauvegardé 6 octets grâce à Ben Owen en utilisant la multiplication de chaînes pour les trois rangées du milieu, et un octet supplémentaire grâce à Matt .

La sortie est comme suit avec 227 octets, soit une réduction de 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

JavaScript, 110 109 octets (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))
)

La sortie est 227 octets:

 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), 194, 181 octets (IGOLF / ANY)

Celui-ci est long et n'est pas vraiment optimisé (pas encore du moins), mais peut être modifié pour imprimer un message particulier, en modifiant uniquement les données bitmap.

EDIT: remplacement de la réduction interne par la carte , utilisation du décalage de bits pour le remplissage

Golfé

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

Démo

[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         

Théorie

Prenez une lettre:

IIIII      
  I        
  I        
  I        
IIIII 

convertissez-le en matrice binaire (bitmap)

11111
00100
00100
00100
11111

faire la même chose pour les 4 autres lettres, balayer une ligne, en enlevant les "premiers" 5 bits

11111 01110 01110 10000 11111

convertir en une chaîne hexadécimale (devrait utiliser ici base36 ou même imprimer ASCII)

0x1f73a1f

appliquer le même algorithme à 4 autres lignes, pour obtenir le bitmap.

Rendu dans l'ordre inverse.

PHP, 107 104 102 94 86 octets

Ok, je suis convaincu que j'ai maintenant la plus petite source possible avec cette méthode. J'ai écrit un script pour générer puis gzip toutes les combinaisons possibles de cinq lettres. Il existe deux solutions qui correspondent au plus court compressé - LODIC et LDOIC. Je vais avec l'ancien parce que c'est plus amusant à dire.

La source:

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

Sortie:

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

C'était amusant.
Je me sens obligé de revenir et d’essayer de jouer au golf quand j’ai le temps.

Utilise le codage CP-1252 .
Inspiré par la réponse de carusocomputing .

ECOIH

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

Essayez-le en ligne!

Explication

‘ÓÑOIHH‘pousse la ficelle "ECOOIHH".

SðýJ3×Sjoint la chaîne par des espaces, la répète trois fois et la convertit en liste.
La liste résultante est ['E', ' ', 'C', ' ', 'O', ' ', 'O', ' ', 'I', ' ', 'H', ' ', 'H', 'E', ' ', 'C', ' ', 'O', ' ', 'O', ' ', 'I', ' ', 'H', ' ', 'H', 'E', ' ', 'C', ' ', 'O', ' ', 'O', ' ', 'I', ' ', 'H', ' ', 'H'].

•Td<UÕ‘áÓ?¢tWvkÔÚ•pousse le nombre 564631055513119191317171314619131717500.

S)ø compresse la liste et le numéro ensemble.

ü×Jfait la répétition de chaîne par paire et les assemble.
Le résultat est la chaîne EEEEE CCCC OOO IIIII H HE C O O I H HEEEE C O O I HHHHH.

3äû»scinde cela en 3 morceaux, ajoute les premier et deuxième morceaux dans l'ordre inverse et se joint par des nouvelles lignes.

JavaScript (ES6), 96 octets (DIOCL)

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

L'idée ici est non seulement de rendre les trois lignes du milieu identiques, mais également de rendre la première ligne presque identique à la dernière. Comme il n’ya que 4 lettres qui correspondent parfaitement à cette description CDIO, Lc’est la deuxième meilleure option, car elle ne nécessite que 4 caractères ajoutés à la fin de la chaîne.

Comme pour la réponse de Florent , il s'agit d'un extrait qui renvoie le résultat. Ajoutez 3 octets si cela doit être une fonction.

Extrait de test

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

Bash + coreutils with figlet, solutions 55440, 112 106 octets chacun

 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

Sortie:

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

Hé, nous avons déjà un programme pour l'art ASCII! La police de la bannière fait presque l'affaire, sauf qu'elle génère 7 lettres sur 7. Hmm, retirons simplement les 3ème et 5ème colonnes, et les 2ème et 5ème lignes, et voyons ce que cela donne ...

Il s’avère que de nombreuses lettres seront imprimées de la manière requise, à savoir BDEFHJLPTU Z.

Il suffit de remplacer les arguments de la première commande set par une combinaison de ces lettres pour obtenir un résultat correct! Par conséquent, cela nous donne 11 * 10 * 9 * 8 * 7 = 55440 solutions, chacune de celles-ci faisant 106 octets de long.

05AB1E , 102 90 89 69 octets (EOIXC)

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

Essayez-le en ligne!

Sortie (230 octets):

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% de compression

Explication:

La théorie était de choisir des lettres à symétrie verticale, puis de coder les 3 premières lignes et de les palindromiser. Fondamentalement, j'ai codé comme {#} sur {Lettre} par paires de 2 octets. Je suis sûr qu'il existe un meilleur moyen de le faire.

•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 octets grâce à Emigna, je serai dans le chat pour poser quelques questions bientôt;).

JavaScript ES6, 168 octets, CHAMP

Nous pouvons cesser de regarder les gars, nous avons un CHAMPici

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 octets

Mieux refaire:

Celui-ci fait un meilleur travail pour optimiser la bande, en sacrifiant les caractères de configuration pour l'impression des caractères. La bande dans celle-ci ressemble 'C' 'E' ' ' 'F' 'I' 'L' '\n', améliorant l'efficacité. J'ai choisi ceux-ci parce qu'ils manquaient d'espaces internes, ce qui leur permettait de ne pas avoir à aller et venir plus que nécessaire entre le personnage et l'espace.

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

Si vous voulez lire ce qu'il fait:

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

Sortie:

 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

Ancienne soumission:

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

J’ai choisi ABCDE parce que cela facilite beaucoup le réglage de la bande pour la sortie, mais le temps et les caractères que j’ai perdus en allant de la lettre à "" pour tout l’espace négatif à l’intérieur des A, B et D et le placement de la ligne de fond à la fin de la bande m'a un peu tué, je pense.

Je me suis retrouvé avec une bande qui avait les valeurs 0 0 'A' 'B' 'C' 'D' 'E' ' ' \net ensuite sortie de 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

Sortie:

 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 octets 99 octets

ELITC

Il a joué moins de 100 avec l’aide de @DrMcMoylex.

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

Celui-ci contient des caractères non imprimables, je les ai donc ajoutés ci-dessous (style Vim) pour que vous puissiez les voir.

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

TryItOnline!

Il utilise fondamentalement le même décodage de durée que la réponse de gelée. J'ai utilisé des lettres où je pourrais (espérons-le) répéter le haut en bas et les médiums seraient tous 3 identiques. Une fois que les sommets, les bas et les milieux sont créés, je modifie les caractères pour les corriger:

1. Ajouter deux espaces au I (plus sur celui ci-dessous)
2. Ajouter deux espaces au T
3. Ajouter la barre du E
4. Retirer le haut du L
5. Retirez le bas du T (et supprimez les 2 espaces)

Je dois ajouter deux espaces au I, car je n’autorisais pas les nombres à deux chiffres (je n’aurais donc pas besoin de séparateur. Ceci conduit à une séquence de 9 espaces où il me faut 11.

MATL , 49 octets

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

Essayez-le en ligne!

Cela produit les lettres 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

Explication

Test relativement facile à construire à partir de zéro. Ipeut être obtenu essentiellement en Tplus de sa réflexion verticale. Hest Itransposé. Nest Ztransposé et réfléchi verticalement.

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 octets

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

Essayez-le en ligne!

Cela génère 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 octets (ABCDE)

Remarque : ceci contient des caractères non imprimables, échappés pour faciliter les tests ici, image xxdci-dessous.

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

Stocke la représentation binaire des positions des lettres sous forme de nombre, puis décompresse en binaire, en remplaçant 0s par des espaces et 1s par la lettre correspondante, à l'aide d'une recherche. Stocker les représentations de lettre est assez facile, mais les remplacer s'est avéré plus compliqué que je ne l'aurais espéré. Je suis sûr qu'il existe de meilleures façons de le faire, donc je pourrais bien continuer à jouer avec cela.

Pour recréer le fichier, lancez xxd -r > favourite-letter.pl, collez le ci-dessous et appuyez sur 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

Usage

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 octets

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

Semblable à mon autre réponse , mais avec de meilleurs choix de lettres. Sortie ceci:

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 octets (CKYTF)

La source

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

Sortie

  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

Essayez-le en ligne!

Au cas où cela serait important, je dois signaler que ma sortie comporte un espace de début sur chaque ligne. Les règles ne l'interdisaient pas explicitement, alors j'espère que ça ira. Si ce n'est pas le cas, considérez simplement qu'il s'agit d'une entrée non concurrente.

Explication

Les lettres du mot sont codées comme une simple séquence de 25 entiers, chaque entier étant une représentation binaire de 5 pixels. Étant donné que Befunge vous oblige à effectuer un calcul pour instancier tout entier supérieur à 9, les lettres ont été choisies de manière à minimiser le nombre de calculs nécessaires, et ordonnées afin que les valeurs répétées potentielles puissent être dupliquées plutôt que recalculées.

Nous devons également stocker la valeur ASCII de chaque lettre, décalée de 32, dans un tableau indexé par le modulo 5 d'un index de décrémentation (donc 0 4 3 2 1 ...). La raison de la compensation par 32 est que la valeur peut être multipliée par un bit de pixel (1 ou 0) puis ajoutée à 32 pour produire un espace ou le caractère requis.

Ce tableau de valeurs de lettre est stocké dans les 5 premiers octets du code, ce qui facilite son accès. Cela a également influencé le choix des lettres, car ces valeurs devaient être significatives lorsqu'elles étaient interprétées comme une séquence de code. Ceci est la séquence #&49+. Le #saute par-dessus le &et le 49+juste pousse 13 sur la pile, qui est par la suite ignorée.

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

Impressions

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: sauvé des caractères en évitant joinet en déplaçant des choses

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

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

Essayez-le en ligne!

Entrée (115 caractères):

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'entrée est la version entière d'un nombre binaire au format aaaaabbbbbboù aaaaaest une carte inversée du caractère à imprimer (par exemple, la deuxième ligne du N est NN N, donc le masque est 10011), et bbbbbbcorrespond au caractère ascii à imprimer, moins 32 .

J'ai également créé un programme befunge-98 pour créer mes entrées:

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

Essayez-le en ligne!

Sortie (255 caractères):

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% de compression

Explication:

: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

C'est probablement assez golfable; J'ai passé très peu de temps à réfléchir aux réductions potentielles.

Théoriquement, cela permet d’imprimer n’importe quelle séquence d’art 5x5 en format ASCII.

Merci à James Holderness de m'aider à sortir du triple chiffre!

C #, 290 279 267 265 octets

Edit: 12 octets sauvés grâce à @milk! Et 2 autres grâce à @TheLethalCoder

Golfé:

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

Les sorties:

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

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

Exécuter et déboguer

J'ai pris des lettres qui

• avoir une symétrie verticale
• dont les trois colonnes du milieu sont identiques

Ces propriétés signifient que chaque lettre peut être représentée par une grille 3x3. Voici les 9 régions, représentées par des chiffres.

12223
45556
78889
45556
12223

Considérons la lettre "B". Il peut être représenté par 3 chiffres octaux: 656. Chaque chiffre contient trois bits, qui contrôlent les régions activées pour cette lettre. Cette technique fonctionne également pour "CDEO".

Décompressé, non golfé et commenté, le programme ressemble à ceci.

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

Exécuter celui-ci

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

Impressions:

 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 octets

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)

Ne gagnera pas, mais n'utilisera aucune compression. Cela fait ceci:

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

Toute aide est la bienvenue, j'ai probablement manqué quelque chose. Je n'ai pas utilisé Python 2 car vous ne pouvez pas le faire p=print, ce qui économise 17 octets. Essayez-le sur repl.it.

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

J'ai choisi des lettres nécessitant un seul bloc de lettres (1, 4 ou 5 lettres) sur chaque ligne. F, L et E sont justifiés à gauche, mais T et I requièrent des espaces de début où une seule lettre (partie verticale) est imprimée. Le code permettant d'ajouter ces espaces semble pouvoir être amélioré.

non-golfé

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

Si les droits implicites sont autorisés, il est possible de couper 8 octets supplémentaires.

#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

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

Comment ça marche: La macro R ne fait que répéter 5 fois un morceau de code. Étant donné la fréquence à laquelle cinq dans ce problème apparaissent, ce qui est très utile. Maintenant: voici ce que fait T (int). T prend un entier et l'utilise comme champ de bits pour déterminer où imprimer des lettres et où imprimer des espaces. Par exemple, si on leur donne T(0b11111111100111111110011100), il affichera: EEEEE DDDD CCCC BBBB AAA. Il décompte progressivement la lettre imprimée. D'abord, il affiche E, puis D, puis C, puis B, puis A. Si vous appelez f (), tout sera imprimé.

Lot, 135 octets (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

Remarque: la première ligne se termine par 5 espaces.

FRAPPER, 95, 111 octets (EBASH)

Golfé

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

Explication

Base64 sur un flux d'octets LZMA brut

Démo

>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

Avertissement

Oui, je sais bien que ce n'est pas vraiment portable, c'est pourquoi j'ai payé un octet pour supprimer les avertissements xz avec -q dans le premier cas> :)

Python 2, 208 194 193 octets

C'est mon tout premier golf de code;) Fun à faire

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

Sortie:

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'utilisation d'un dictionnaire détruit l'ordre de tri des lettres, mais ce n'était pas une obligation

perl 94 octets.

Les 4 premières lettres ( D, O, I, C) sont spécifiquement choisis pour avoir des lignes supérieures et inférieures semblables, et celles du milieu similaire. Comme il n'y a pas d'autre lettre similaire, j'ai choisi le "L" pour pouvoir appliquer le même algorithme et ajouter le 4L manquant.

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

J'ai économisé quelques octets supplémentaires en remplaçant \nle code par une nouvelle ligne.

Résultat:

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