O desafio é realmente extremamente simples. Escolha 5 letras distintas (você pode simplesmente escolher as 5 que permitem o código mais curto, se quiser) e enviá-las para o console. No entanto, a diferença é que eles devem ser da lista a seguir:

 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

Regras adicionais:

• 5 da mesma letra não é permitida, não há opções de repetição.
• Cada letra deve usar a capital em si mesma como caractere ascii para desenhá-la.
• Cada saída de letra deve estar na "mesma linha" e ter 5 espaços entre cada letra.
• Você pode escolher as 5 letras que desejar, permitindo reutilizar algum código e diminuir a contagem de bytes. Descobrir quais letras permitirão que você faça isso com mais eficiência faz parte do desafio.
• Espaços à direita são aceitáveis.
• Uma única nova linha à direita é aceitável, mas não mais do que uma nova linha à direita.
• Isso é código-golfe, vitórias mais baixas na contagem de bytes.

Exemplos:

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    

LOUCO

 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ão tenha medo de enviar mais de uma resposta com letras diferentes ou estratégias diferentes a cada vez; isso pode ser realizado de várias maneiras diferentes.

Geléia , 41 bytes

LICTE

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

TryItOnline!

Idéia

Use uma decodificação de duração da execução com letras que tenham o meio mais semelhante possível, com apenas uma duração da execução de cada "valor de pixel" por linha por letra.

Coloque um começo simples como "L" para evitar diferentes valores de decodificação do comprimento da execução para as linhas.

Coloque uma letra diferente (não foi possível encontrar 5) das três linhas do meio no final, para que a menor diferença possa ser adicionada aritmeticamente.

Saída desejada; os comprimentos de execução; e estes convertidos da 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

Os três valores 399633415, 431646160e 1179122455na base de 250como índices de página de código de geléia são em seguida ðƁ ƥ, ȷɓSɠe JrŀṘque pode ser utilizada para encapsular a informação de comprimento de sequncia.

O 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

Carvão , 51 49 bytes (ECXKI)

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

Saídas

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

Experimente online!

Usando caracteres que são verticalmente simétricos, desenha as metades superiores e depois reflete. A maioria deles usa Polygon ( Ｇ) e PolygonHollow ( ＧＨ) para desenhar uma série de segmentos de linha conectados com um caractere específico. Ipode ser feito mais facilmente com o MultiPrint ( Ｐ), usando Tcomo a direção.

Nota: PolygonHollow apenas desenha os segmentos especificados, sem concluir o polígono ou preenchê-lo. O polígono será concluído e preenchido (não o que queremos) se o polígono puder ser concluído com uma linha simples em uma das oito direções cardinais ou intercardinais. Caso contrário, ele se comporta como o PolygonHollow, para economizar um byte.

A ordem dos caracteres foi escolhida para exigir apenas movimentos horizontais do ponto final de um para o início do próximo. Veja como o cursor prossegue:

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

A idéia é maximizar os espaços entre as letras para que possamos obter compressões repetidas.

Empresta o truque da deduplicação da linha do meio da resposta de Florent . Economizou 6 bytes graças a Ben Owen usando a multiplicação de cadeias para as três linhas do meio e um byte adicional graças a Matt .

A saída é a seguinte em 227 bytes, para uma redução 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 bytes (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))
)

A saída é 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 / QUALQUER)

Este é longo e não está realmente otimizado (pelo menos ainda não), mas pode ser modificado para imprimir qualquer mensagem em particular, alterando apenas os dados de bitmap.

EDIT: Substituído interior reduzir com mapa , use mudança pouco para preenchimento

Golfe

[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         

Teoria

Pegue uma carta:

IIIII      
  I        
  I        
  I        
IIIII 

convertê-lo em matriz binária (bitmap)

11111
00100
00100
00100
11111

faça o mesmo com outras 4 letras, digitalize uma linha, retirando "top" 5 bits de cada

11111 01110 01110 10000 11111

converter para uma cadeia hexadecimal (deve usar base36 ou até ASCII imprimível aqui)

0x1f73a1f

aplique o mesmo algoritmo a outras 4 linhas, para obter o bitmap.

Renderize na ordem inversa.

PHP, 107 104 102 94 86 bytes

Ok, estou confiante de que tenho a menor fonte possível com esse método agora. Eu escrevi um script para gerar e depois compactar todas as combinações possíveis de cinco letras. Existem duas soluções que correspondem aos menores compactados - LODIC e LDOIC. Eu vou com o primeiro porque é mais divertido dizer.

Fonte:

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

Resultado:

% 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

Essa foi engraçada.
Sinto que preciso voltar e tentar jogar um pouco mais quando tiver tempo.

Usa a codificação CP-1252 .
Inspirado pela resposta do carusocomputing .

ECOIH

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

Experimente online!

Explicação

‘ÓÑOIHH‘empurra a corda "ECOOIHH".

SðýJ3×Sjunta a string por espaços, repete-a três vezes e a converte em uma lista.
A lista resultante é ['E', ' ', 'C', ' ', 'O', ' ', 'O', ' ', 'I', ' ', 'H', ' ', 'H', 'E', ' ', 'C', ' ', 'O', ' ', 'O', ' ', 'I', ' ', 'H', ' ', 'H', 'E', ' ', 'C', ' ', 'O', ' ', 'O', ' ', 'I', ' ', 'H', ' ', 'H'].

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

S)ø fecha a lista e o número juntos.

ü×Jfaz repetição de cordas em pares e as junta.
O resultado é a sequência EEEEE CCCC OOO IIIII H HE C O O I H HEEEE C O O I HHHHH.

3äû»divide isso em 3 partes, adiciona a primeira e a segunda peça na ordem inversa e junta-se por novas linhas.

JavaScript (ES6), 96 bytes (DIOCL)

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

A idéia aqui é não apenas tornar as três linhas do meio idênticas, mas também tornar a primeira linha quase idêntica à anterior. Como existem apenas 4 letras que se encaixam perfeitamente nessa descrição CDIO, Lé a próxima melhor opção, pois requer apenas 4 caracteres adicionados no final da string.

Como na resposta de Florent , este é um trecho que retorna o resultado. Adicione 3 bytes se precisar ser uma função.

Snippet de teste

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

Bash + coreutils com figlet, 55440 soluções, 112 106 bytes cada

 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

Resultado:

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

Ei, já temos um programa de arte ASCII! A fonte do banner quase faz o trabalho, exceto que gera 7x7 letras. Hmm, vamos remover as 3ª e 5ª colunas, e as 2ª e 5ª linhas, e ver o que ela oferece ...

Acontece que muitas letras serão exibidas da maneira necessária, a saber, BDEFHJLPTU Z.

Basta substituir os argumentos do primeiro comando set por qualquer combinação dessas letras para obter o resultado correto! Portanto, isso nos fornece 11 * 10 * 9 * 8 * 7 = 55440 soluções, cada uma delas com 106 bytes de comprimento.

05AB1E , 102 90 89 69 bytes (EOIXC)

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

Experimente online!

Saída (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 compressão

Explicação:

A teoria era escolher letras simétricas verticalmente, depois codificar as 3 primeiras linhas e palindromizá-las. Basicamente, codifiquei como {#} de {Letter} em pares de 2 bytes. Tenho certeza de que há uma maneira melhor de fazer isso.

•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 graças a Emigna, estarei no chat para fazer algumas perguntas em breve;).

JavaScript ES6, 168 bytes, CHAMP

Podemos parar de procurar gente, temos um CHAMPaqui

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

Melhor refazer:

Este faz um trabalho melhor na otimização da fita, sacrificando os caracteres de configuração para imprimir caracteres. A fita neste parece 'C' 'E' ' ' 'F' 'I' 'L' '\n', melhorando a eficiência. Eu os escolhi porque eles não têm espaços internos, fazendo com que eles não precisem ir e voltar entre o caráter e o espaço mais do que o necessário

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

Se você quiser ler o que está fazendo:

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

Resultado:

 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

Submissão anterior:

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

Eu escolhi ir com o ABCDE porque facilita a configuração da fita para saída, mas o tempo e os caracteres que eu desperdicei indo da letra para '' para todo o espaço negativo dentro de A, B e D e a colocação de a linha final no final da fita meio que me matou, eu acho.

Acabei com uma fita que tinha os valores 0 0 'A' 'B' 'C' 'D' 'E' ' ' \ne depois saí 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

Resultado:

 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

Jogou menos de 100 com a ajuda de @DrMcMoylex.

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

Como contém caracteres não imprimíveis, os adicionei abaixo (estilo Vim), para que você possa vê-los.

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

TryItOnline!

Basicamente, usa a mesma decodificação de execução que a resposta da geléia. Usei letras nas quais eu poderia (espero) repetir a parte superior na parte inferior, e os médios seriam todos iguais. Depois que as partes superior, inferior e intermediária são criadas, edito os caracteres para corrigi-los:

1. Adicione dois espaços ao I (mais sobre isso abaixo)
2. Adicione dois espaços ao T
3. Adicione a barra do E
4. Retire a parte superior do L
5. Remova a parte inferior do T (e exclua os 2 espaços)

Eu tenho que adicionar dois espaços ao I, porque não permiti números de dois dígitos (para que eu não precisasse de um separador. Isso leva a uma execução de 9 espaços onde eu preciso de 11.

MATL , 49 bytes

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

Experimente online!

Isso produz as 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

Explicação

Té relativamente fácil de construir a partir do zero. Ipode ser obtido essencialmente como Tmais sua reflexão vertical. Hé Itransposto. Né Ztransposto e refletido 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

Experimente online!

Isso gera 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 : contém caracteres não imprimíveis, escapados para facilitar o teste aqui, xxddespejo abaixo.

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

Armazena a representação binária das posições da letra como um número e depois descompacta novamente no binário, substituindo 0s por espaços 1es pela letra correspondente, usando uma pesquisa. Armazenar as representações das letras é bastante fácil, mas substituí-las ficou mais complicado do que eu esperava. Tenho certeza de que existem maneiras melhores de fazer isso, para que eu possa continuar a brincar com isso.

Para recriar o arquivo, execute xxd -r > favourite-letter.pl, cole o abaixo e pressione 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

Semelhante à minha outra resposta , mas com melhores opções de letras. Emite isso:

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

Anterior, 120 bytes (CKYTF)

Fonte

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

Resultado

  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

Experimente online!

Caso isso importe, devo salientar que minha saída possui um espaço à esquerda em cada linha. As regras não proíbem explicitamente isso, então espero que esteja tudo bem. Caso contrário, considere esta entrada como não concorrente.

Explicação

As letras da palavra são codificadas como uma sequência simples de 25 números inteiros, cada número inteiro sendo uma representação binária de 5 pixels. Como o Befunge exige que você execute um cálculo para instanciar qualquer número inteiro maior que 9, as letras foram escolhidas para minimizar o número de cálculos necessários e ordenadas para que possíveis valores repetidos pudessem ser duplicados em vez de recalculados.

Também precisamos armazenar o valor ASCII de cada letra, deslocada por 32, em uma matriz que é indexada pelo módulo 5 de um índice decrescente (para que seja 0 4 3 2 1 ...). O motivo da compensação por 32 é que o valor pode ser multiplicado por um bit de pixel (1 ou 0) e depois adicionado a 32 para produzir um espaço ou o caractere necessário.

Essa matriz de valores de letras é armazenada nos primeiros 5 bytes do código, facilitando o acesso. Isso também influenciou a escolha das letras, pois esses valores precisavam ter significado quando interpretados como uma sequência de código. Esta é a sequência #&49+. Os #saltos sobre a &ea 49+apenas empurra 13 para a pilha que é posteriormente ignorado.

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

Impressões

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: salvou alguns caracteres, evitando joine movendo as coisas

Befunge-98 , 109 98 bytes (FUNGE / QUALQUER)

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

Experimente online!

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

Input é a versão inteira de um número binário com o formato em aaaaabbbbbbque aaaaaé um mapa invertido do caractere a ser impresso (por exemplo, a segunda linha no N é NN N, portanto a máscara é 10011) e bbbbbbé o caractere ascii a ser impresso, menos 32 .

Também criei um programa befunge-98 para criar minhas entradas:

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

Experimente online!

Saída (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 compressão

Explicação:

: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

Provavelmente isso é bastante jogável; Passei quase algum tempo pensando em possíveis reduções.

Teoricamente, isso pode imprimir qualquer sequência da arte ASCII 5x5.

Agradeço a James Holderness por me ajudar a sair de três dígitos!

C #, 290 279 267 265 Bytes

Editar: salvou 12 bytes graças a @milk! E mais 2 graças a @TheLethalCoder

Golfe:

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

Saídas:

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

Execute e depure

Eu escolhi cartas que

• tem simetria vertical
• cujas três colunas do meio são idênticas

Essas propriedades significam que cada letra pode ser representada por uma grade 3x3. Aqui estão as 9 regiões, representadas por dígitos.

12223
45556
78889
45556
12223

Considere a letra "B". Ele pode ser representado por 3 dígitos octais: 656. Cada dígito contém três bits, que controlam quais regiões estão ativadas para essa letra. Essa técnica também funciona para "CDEO".

Descompactado, desmontado e comentado, o programa se parece com isso.

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

Execute este

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

Impressões:

 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)

Não vai ganhar, mas não usa nenhuma compactação. Faz isto:

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

Qualquer ajuda é bem-vinda, provavelmente perdi alguma coisa. Eu não usei o Python 2 porque você não pode fazer isso p=print, e isso economiza 17 bytes. Experimente em 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

Escolhi letras que exigiam um único bloco de letras (1,4 ou 5 letras) em cada linha. F, L e E são deixados justificados, mas T e eu exigem espaços à esquerda onde uma única letra (parte vertical) é impressa. O código para adicionar esses espaços parece que poderia ser melhorado.

destroçado

"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

Se entradas implícitas são permitidas, é possível cortar outros 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

Saída: 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     

Como funciona: A macro R apenas repete um pedaço de código 5 vezes. Dada a frequência com que cinco aparecem neste problema, é muito útil. Agora: aqui está o que T (int) faz. T pega um número inteiro e o usa como um campo de bits para determinar onde imprimir letras e onde imprimir espaço em branco. Por exemplo, se for dado T(0b11111111100111111110011100), ele irá imprimir: EEEEE DDDD CCCC BBBB AAA. Ele conta progressivamente a letra que imprime. Primeiro, imprime E, depois D, depois C, depois B e depois A. Chamar f () imprimirá a coisa toda.

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: a primeira linha termina em 5 espaços.

BATER, 95, 111 bytes (EBASH)

Golfe

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

Explicação

Base64 sobre fluxo de bytes brutos LZMA

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

aviso Legal

Sim, estou ciente de que isso não é realmente portátil, por isso paguei um byte para suprimir os avisos xz com -q no primeiro caso> :)

Python 2, 208 194 193 bytes

Este é o meu primeiro código de golfe;) Divertido de fazer

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

Resultado:

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

O uso de um dicionário destrói a ordem de classificação das letras, mas isso não era um requisito

perl 94 bytes.

Os primeiros 4 letras ( D, O, I, C) são especificamente escolhidos para ter as linhas superior e inferior semelhantes, e os do meio semelhante. Como não há outra letra similar, escolhi o "L" para poder aplicar o mesmo algoritmo e adicionar o 4L ausente.

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

Salvei alguns bytes extras substituindo \no código por uma nova linha 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