El desafío es realmente extremadamente simple. Elija 5 letras distintas (puede elegir las 5 que le permiten el código más corto si lo desea) y envíelas a la consola. Sin embargo, el giro es que deben ser de la siguiente lista:

 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

Reglas Adicionales:

• 5 de la misma letra no está permitido, no hay opciones de repetición.
• Cada letra debe usar la capital de sí misma como carácter ascii para dibujarla.
• Cada salida de letra debe estar en la "misma línea" y tener 5 espacios entre cada letra.
• Puede elegir las 5 letras que desee, esto le permitirá reutilizar algunos códigos y reducir el recuento de bytes. Averiguar qué letras le permitirán hacer esto de manera más eficiente es parte del desafío.
• Los espacios finales son aceptables.
• Una nueva línea final es aceptable, aunque no más de una nueva línea final.
• Este es el código de golf, el menor recuento de bytes gana.

Ejemplos:

A B C D E

 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    

LOCA

 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  

No tenga miedo de enviar más de una respuesta con diferentes letras o diferentes estrategias cada vez, esto se puede lograr de varias maneras diferentes.

Jalea , 41 bytes

LICTE

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

TryItOnline!

Idea

Utilice un decodificador de longitud de ejecución con letras que tengan el medio más similar posible con solo una longitud de ejecución de cada "valor de píxel" por fila por letra.

Ponga un inicio plano como "L" para evitar diferentes valores de decodificación de longitud de ejecución para las filas.

Coloque la letra diferente (no pudo encontrar 5) de las tres filas del medio al final para que la diferencia más pequeña se pueda agregar aritméticamente.

Salida deseada; las longitudes de carrera; y estos convertidos 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

Los tres valores 399633415, 431646160y 1179122455en la base 250como índices de página de código de jalea son entonces ðƁ ƥ, ȷɓSɠy JrŀṘque se pueden utilizar para encapsular la información de longitud de ejecución.

El código

“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

Carbón , 51 49 bytes (ECXKI)

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

Salidas

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

Pruébalo en línea!

Usando caracteres que son simétricos verticalmente, dibuja las mitades superiores y luego refleja. La mayoría de estos utilizan Polygon ( Ｇ) y PolygonHollow ( ＧＨ) para dibujar una serie de segmentos de línea conectados con un carácter particular. Ise puede hacer más fácilmente con MultiPrint ( Ｐ), utilizando Tcomo dirección.

Nota: PolygonHollow solo dibuja los segmentos especificados, sin completar el polígono ni llenarlo. El polígono se completará y rellenará (no lo que queremos) si el polígono se puede completar con una línea simple en una de las ocho direcciones cardinales o intercardinales. De lo contrario, se comporta como PolygonHollow, para un ahorro de un byte.

Se eligió el orden de los caracteres para requerir solo movimientos horizontales desde el punto final de uno hasta el comienzo del siguiente. Así es como avanza el cursor:

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

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

La idea es maximizar los espacios entre las letras para que podamos obtener compresiones repetidas.

Toma prestado el truco de deduplicación de la fila media de la respuesta de Florent . Ahorré 6 bytes gracias a Ben Owen usando la multiplicación de cadenas para las tres filas del medio, y un byte adicional gracias a Matt .

La salida es como la siguiente en 227 bytes, para una reducción 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

JavaScript, 110 109 bytes (NUBE)

` 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 salida es de 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), 194, 181 bytes (IGOLF / CUALQUIER)

Este es largo y no está realmente optimizado (al menos aún), pero puede modificarse para imprimir cualquier mensaje en particular, solo cambiando los datos del mapa de bits.

EDITAR: Reemplazo interno reducido con mapa , uso bit shift para relleno

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`

Manifestación

[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         

Teoría

Toma una carta:

IIIII      
  I        
  I        
  I        
IIIII 

convertirlo a matriz binaria (mapa de bits)

11111
00100
00100
00100
11111

haga lo mismo para otras 4 letras, escanee una línea, quitando 5 bits "superiores" de cada

11111 01110 01110 10000 11111

convertir a una cadena hexadecimal (debería usar base36 o incluso ASCII imprimible aquí)

0x1f73a1f

aplique el mismo algoritmo a otras 4 líneas, para obtener el mapa de bits.

Render en el orden inverso.

PHP, 107 104 102 94 86 bytes

Ok, estoy seguro de que tengo la fuente más pequeña posible con este método ahora. Escribí un script para generar y luego comprimir cada combinación posible de cinco letras. Hay dos soluciones que coinciden con la compresión más corta: LODIC y LDOIC. Voy con el primero porque es más divertido decirlo.

Fuente:

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

Salida:

% 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

Esto fue divertido.
Siento que necesito volver e intentar jugar un poco más cuando tenga tiempo.

Utiliza la codificación CP-1252 .
Inspirado por la respuesta de carusocomputing .

ECOIH

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

Pruébalo en línea!

Explicación

‘ÓÑOIHH‘empuja la cuerda "ECOOIHH".

SðýJ3×Sune la cadena por espacios, la repite tres veces y la convierte en una lista.
La lista resultante es ['E', ' ', 'C', ' ', 'O', ' ', 'O', ' ', 'I', ' ', 'H', ' ', 'H', 'E', ' ', 'C', ' ', 'O', ' ', 'O', ' ', 'I', ' ', 'H', ' ', 'H', 'E', ' ', 'C', ' ', 'O', ' ', 'O', ' ', 'I', ' ', 'H', ' ', 'H'].

•Td<UÕ‘áÓ?¢tWvkÔÚ•empuja el número 564631055513119191317171314619131717500.

S)ø comprime la lista y el número juntos.

ü×Jrealiza la repetición de cuerdas por pares y las une.
El resultado es la cadena EEEEE CCCC OOO IIIII H HE C O O I H HEEEE C O O I HHHHH.

3äû»divide eso en 3 piezas, agrega la primera y la segunda pieza en orden inverso y se une por líneas nuevas.

JavaScript (ES6), 96 bytes (DIOCL)

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

La idea aquí es no solo hacer que las tres líneas del medio sean idénticas, sino también hacer que la primera línea sea casi idéntica a la última. Dado que solo hay 4 letras que se ajustan perfectamente a esta descripción CDIO, Les la siguiente mejor opción, ya que solo requiere 4 caracteres agregados al final de la cadena.

Al igual que con la respuesta de Florent , este es un fragmento que devuelve el resultado. Agregue 3 bytes si necesita ser una función.

Fragmento de prueba

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

Bash + coreutils con figlet, 55440 soluciones, 112 106 bytes cada uno

 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

Salida:

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

¡Hola, ya tenemos un programa para el arte ASCII! La fuente del banner casi hace el trabajo, excepto que genera letras 7x7. Hmm, eliminemos las columnas 3ra y 5ta, y las líneas 2da y 5ta, y veamos qué da ...

Resulta que muchas letras se emitirán de la manera requerida, a saber, BDEFHJLPTU Z.

¡Es suficiente reemplazar los argumentos del primer comando set con cualquier combinación de esas letras para obtener un resultado correcto! Por lo tanto, esto nos da 11 * 10 * 9 * 8 * 7 = 55440 soluciones, cada una de ellas con 106 bytes de longitud.

05AB1E , 102 90 89 69 bytes (EOIXC)

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

Pruébalo en línea!

Salida (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% de compresión

Explicación:

La teoría era elegir letras simétricas verticalmente, luego codificar las primeras 3 líneas y palindromizarlas. Básicamente, codifiqué como {#} de {Letter} en pares de 2 bytes. Estoy seguro de que hay una mejor manera de hacer esto.

•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 gracias a Emigna, pronto estaré en el chat para hacer algunas preguntas;).

JavaScript ES6, 168 bytes, CHAMP

Podemos dejar de buscar chicos, tenemos un CHAMPpor aquí

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

Mejor rehacer:

Este hace un mejor trabajo al optimizar la cinta, sacrificando los caracteres de configuración para imprimir caracteres. La cinta en este se ve 'C' 'E' ' ' 'F' 'I' 'L' '\n', mejorando la eficiencia. Elegí estos porque carecen de espacios internos, por lo que no tienen que ir y venir entre el personaje y el espacio más de lo necesario

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

Si quieres leer lo que está haciendo:

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

Salida:

 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

Sumisión anterior:

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

Elegí ir con ABCDE porque hace que la configuración de la cinta para la salida sea mucho más fácil, pero el tiempo y los caracteres que perdí al pasar de la letra a '' para todo el espacio negativo dentro de A, B y D y la colocación de Creo que la línea final al final de la cinta me mató un poco.

Terminé con una cinta que tenía los valores 0 0 'A' 'B' 'C' 'D' 'E' ' ' \ny luego la salida desde allí

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

Salida:

 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

Golfed menos de 100 con la ayuda de @DrMcMoylex.

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

Contiene caracteres no imprimibles, por lo que los he agregado a continuación (estilo Vim), para que pueda verlos.

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

TryItOnline!

Básicamente utiliza la misma decodificación de longitud de ejecución que la respuesta de jalea. Usé letras donde podía (con suerte) repetir la parte superior en la parte inferior, y los medios serían los mismos 3. Una vez que se crean las partes superior, inferior y media, edito los caracteres para corregirlos:

1. Agregue dos espacios a la I (más sobre eso a continuación)
2. Agregue dos espacios a la T
3. Agrega la barra de la E
4. Retire la parte superior de la L
5. Retire la parte inferior de la T (y elimine los 2 espacios)

Tengo que agregar dos espacios a la I, porque no permití números de dos dígitos (por lo que no necesitaría un separador. Esto lleva a una carrera de 9 espacios donde necesito 11.

MATL , 49 bytes

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

Pruébalo en línea!

Esto produce las letras 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

Explicación

TEs relativamente fácil de construir desde cero. Ise puede obtener esencialmente como Tmás su reflejo vertical. Hse Itranspone Nse Ztranspone y se refleja 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

V , 62 , 53 bytes

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

Pruébalo en línea!

Esto 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

Perl, 109 bytes (ABCDE)

Nota : esto contiene caracteres no imprimibles, escapados para facilitar la prueba aquí, xxdvolcar a continuación.

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

Almacena la representación binaria de las posiciones de las letras como un número, luego desempaqueta nuevamente en binario, reemplazando 0s con espacios 1ys con la letra correspondiente, usando una búsqueda. Almacenar las representaciones de letras es bastante fácil, pero reemplazarlas resultó más complicado de lo que esperaba. Estoy seguro de que hay mejores maneras de hacer esto, así que podría seguir jugando con esto.

Para recrear el archivo, ejecute xxd -r > favourite-letter.pl, pegue en el siguiente y presione 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     

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

Similar a mi otra respuesta , pero con mejores opciones de letras. Salidas esto:

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)

Fuente

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

Salida

  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

Pruébalo en línea!

En caso de que sea importante, debo señalar que mi salida tiene un espacio inicial en cada línea. Las reglas no lo prohíben explícitamente, así que espero que esté bien. Si no es así, solo considere esto como una entrada no competitiva.

Explicación

Las letras de la palabra están codificadas como una secuencia simple de 25 enteros, cada uno de los cuales es una representación binaria de 5 píxeles. Dado que Befunge requiere que realice un cálculo para crear una instancia de cualquier número entero mayor que 9, las letras se eligieron para minimizar el número de cálculos requeridos, y se ordenaron para que los posibles valores de repetición pudieran duplicarse en lugar de recalcularse.

También necesitamos almacenar el valor ASCII de cada letra, desplazado por 32, en una matriz que está indexada por el módulo 5 de un índice decreciente (por lo que va 0 4 3 2 1 ...). La razón para compensar por 32 es que el valor puede multiplicarse por un bit de píxel (1 o 0) y luego agregarse a 32 para producir un espacio o el carácter requerido.

Este conjunto de valores de letras se almacena en los primeros 5 bytes del código, por lo que es de fácil acceso. Esto también influyó en la elección de las letras, ya que esos valores debían ser significativos cuando se interpretaban como una secuencia de código. Esta es la secuencia #&49+. Los #saltos sobre el &y el 49+justo empujan 13 en la pila que posteriormente se ignora.

Ruby, 110 107 102 bytes (dócil)

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

Huellas dactilares

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

EDITAR: guardó algunos caracteres al evitar joiny mover cosas

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

Pruébalo en línea!

Entrada (115 caracteres):

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

La entrada es la versión entera de un número binario con el formato aaaaabbbbbbdonde aaaaaes un mapa invertido del carácter a imprimir (por ejemplo, la segunda fila en la N es NN N, entonces la máscara es 10011), y bbbbbbes el carácter ASCII para imprimir, menos 32 .

También creé un programa befunge-98 para crear mis entradas:

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

Pruébalo en línea!

Salida (255 caracteres):

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 compresión

Explicación:

: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

Esto es probablemente bastante golfable; Apenas he pasado tiempo pensando en posibles reducciones.

Teóricamente, esto puede imprimir cualquier secuencia de 5x5 ascii art.

¡Gracias a James Holderness por ayudarme a salir de tres dígitos!

C #, 290 279 267 265 Bytes

Editar: ¡Guardado 12 bytes gracias a @milk! Y 2 más gracias a @TheLethalCoder

Golfizado:

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

Sin golf:

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

Salidas:

 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*è«

Ejecutar y depurarlo

Escogí letras que

• tener simetría vertical
• cuyas tres columnas centrales son idénticas

Estas propiedades significan que cada letra se puede representar mediante una cuadrícula de 3x3. Aquí están las 9 regiones, representadas por dígitos.

12223
45556
78889
45556
12223

Considere la letra "B". Puede ser representado por 3 dígitos octales: 656. Cada dígito contiene tres bits, que controlan qué regiones están habilitadas para esa letra. Esta técnica también funciona para "CDEO".

Desempaquetado, sin golf y comentado, el programa se ve así.

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

Ejecute este

Python 3, 234 228 227 166 bytes (NUBE):

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

Huellas dactilares:

 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)

No ganará, pero no usa ninguna compresión. Hace esto:

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

Cualquier ayuda es bienvenida, probablemente me perdí algo. No utilicé Python 2 porque no puedes hacerlo p=print, y eso ahorra 17 bytes. Pruébalo en 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

Escogí letras que requerían un solo bloque de letras (1,4 o 5 letras de largo) en cada línea. F, L y E se dejan justificados, pero T y I requieren espacios iniciales donde se imprime una sola letra (parte vertical). Parece que el código para agregar estos espacios podría mejorarse.

sin 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 bytes

Si se permiten entradas implícitas, entonces es posible cortar otros 8 bytes.

#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

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

Cómo funciona: la macro R simplemente repite un fragmento de código 5 veces. Dada la frecuencia con la que aparecen los cinco en este problema, es muy útil. Ahora: esto es lo que hace T (int). T toma un número entero y lo usa como un campo de bits para determinar dónde imprimir letras y dónde imprimir espacios en blanco. Por ejemplo, si se les da T(0b11111111100111111110011100), que sería: EEEEE DDDD CCCC BBBB AAA. Progresivamente cuenta hacia atrás en cuanto a qué letra imprime. Primero imprime E, luego D, luego C, luego B, luego A. Llamar f () imprimirá todo.

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

Nota: la primera línea termina en 5 espacios.

GOLPETAZO, 95, 111 bytes (EBASH)

Golfed

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

Explicación

Base64 sobre flujo de bytes LZMA sin procesar

Manifestación

>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

Descargo de responsabilidad

Sí, soy consciente de que esto no es realmente portátil, por eso he pagado un byte para suprimir las advertencias xz con -q en el primer caso> :)

Python 2, 208 194 193 bytes

Este es mi primer código de golf;) Diversión para hacer

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

Salida:

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

Usar un diccionario destruye el orden de clasificación de las letras, pero eso no era un requisito

perl 94 bytes.

Los primeros 4 letras ( D, O, I, C) se eligen específicamente para tener las líneas superiores e inferiores similares, y las medias similar. Como no hay ninguna otra letra similar, elegí la "L" para poder aplicar el mismo algoritmo y agregar el 4L faltante.

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

Ahorré algunos bytes adicionales reemplazando el \nen el código con una nueva línea real.

Resultado:

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