挑战实际上非常简单。选择5个不同的字母（如果愿意，您可以选择5个最短的字母）并将它们输出到控制台。但是，不同之处在于它们必须来自以下列表：

 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

附加规则：

• 同一封信中的5条是不允许的，不能重复选择。
• 每个字母都必须使用自身的大写字母作为字母来绘制。
• 每个字母输出必须在“同一行”上，并且每个字母之间有5个空格。
• 您可以选择任意 5个字母，这将使您可以重用一些代码并减少字节数。找出哪些字母将使您最有效地执行此操作是挑战的一部分。
• 尾随空格是可以接受的。
• 一条尾随的换行符是可以接受的，但是最多只能有一条尾随的换行符。
• 这是代码高尔夫，最低字节数获胜。

例子：

美国广播公司

 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    

疯

 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  

不要害怕每次都提交一个以上答案，每个答案带有不同的字母或不同的策略，这可以通过各种不同的方式来完成。

果冻，41 个字节

许可

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

TryItOnline！

理念

使用游程长度解码，使字母的中间位置尽可能相似，并且每个字母每行每个“像素值”的游程长度只有一个。

放置一个像“ L”这样的平坦开头，以避免行的不同游程长度解码值。

在中间的三个行的末尾放置一个不同的字母（找不到5），以便可以算术相加最小的差。

想要的输出；游程长度；这些是从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

这三个值399633415，431646160和1179122455在碱250如果冻代码页索引然后ðƁ ƥ，ȷɓSɠ以及JrŀṘ其可用于封装游程长度信息。

编码

“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

木炭，51 49字节（ECXKI）

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

产出

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

在线尝试！

使用垂直对称的字符绘制上半部分，然后进行反射。其中大多数使用Polygon（Ｇ）和PolygonHollow（ＧＨ）绘制一系列具有特定字符的连接线段。I可以使用MultiPrint（Ｐ）T作为方向来轻松完成操作。

注意：PolygonHollow只会绘制指定的线段，而不会完成多边形或填充它。如果可以在八个基本方向或基本方向之一上用一条简单的线完成多边形，则多边形将完成并填充（不是我们想要的）。否则，它的行为类似于PolygonHollow，节省了一个字节。

选择字符顺序仅要求从一个端点到下一个起点的水平移动。游标前进的方式如下：

PowerShell的V2 +，138 128 114 112 106 105字节（LICTD）

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

我们的想法是最大化字母之间的间隔，以便我们可以重复进行压缩。

从Florent的答案中借用中排重复数据删除技巧。感谢Ben Owen在中间三行中使用字符串乘法，节省了6个字节，而对Matt节省了一个额外的字节。

输出如下所示，为227字节，减少了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字节（云）

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

输出为227字节：

 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字节（IGOLF / ANY）

该消息很长，并且尚未真正优化（至少尚未优化），但是可以通过仅更改位图数据进行修改以打印任何特定消息。

编辑：用map替换了内部reduce，将位移用于填充

打高尔夫球

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

演示版

[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         

理论

来信：

IIIII      
  I        
  I        
  I        
IIIII 

将其转换为二进制矩阵（位图）

11111
00100
00100
00100
11111

对其他4个字母执行相同的操作，扫描一行，方法是将每个“ 5”个字母取下

11111 01110 01110 10000 11111

转换为十六进制字符串（此处应使用base36甚至可打印的ASCII）

0x1f73a1f

将相同的算法应用于其他4行，以获取位图。

以相反的顺序渲染。

PHP，107 104 102 94 86个字节

好的，我有信心现在使用此方法的源代码最少。我写了一个脚本来生成，然后用gzip压缩五个字母的每种可能组合。对于最短的压缩，有两种匹配的解决方案-LODIC和LDOIC。我选择前者，是因为它很有趣。

资源：

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

输出：

% 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个字节

这很有趣。
我觉得我需要回来时再尝试打高尔夫球。

使用CP-1252编码。
受到carusocomputing 答案的启发。

生态经济

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

在线尝试！

说明

‘ÓÑOIHH‘推弦"ECOOIHH"。

SðýJ3×S用空格连接字符串，重复三次，然后将其转换为列表。
结果列表为['E', ' ', 'C', ' ', 'O', ' ', 'O', ' ', 'I', ' ', 'H', ' ', 'H', 'E', ' ', 'C', ' ', 'O', ' ', 'O', ' ', 'I', ' ', 'H', ' ', 'H', 'E', ' ', 'C', ' ', 'O', ' ', 'O', ' ', 'I', ' ', 'H', ' ', 'H']。

•Td<UÕ‘áÓ?¢tWvkÔÚ•推号码564631055513119191317171314619131717500。

S)ø 将列表和数字拉在一起。

ü×J进行成对的字符串重复并将其连接在一起。
结果是字符串EEEEE CCCC OOO IIIII H HE C O O I H HEEEE C O O I HHHHH。

3äû»将其分为3部分，以相反的顺序添加第一部分和第二部分，并以换行符连接。

JavaScript（ES6），96字节（DIOCL）

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

这里的想法不仅是使中间的三行相同，而且使第一行与最后一行几乎相同。由于只有4个字母完全符合此描述CDIO，因此L是下一个最佳选择，因为它仅需要在字符串末尾添加4个字符。

与Florent的答案一样，这是一个返回结果的代码段。如果需要，则添加3个字节。

测试片段

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

击+的coreutils与figlet，55440种溶液，112个每个106字节

 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

输出：

HH EEEEE L PPPP DDDD  
赫尔珀德 
HHHHH EEEE L PPPP DD 
海尔PDD 
HH EEEEE LLLLL P DDDD  
                                              

嘿，我们已经有一个ASCII艺术程序！该横幅的字体几乎没有工作，除了它输出7x7的字母。嗯，我们只删除第三和第五列，以及第二和第五行，看看它能提供什么...

事实证明，将以所需的方式输出许多字母，即BDEFHJLPTUZ。

只需用这些字母的任意组合替换第一个set命令的参数即可，以获得正确的结果！因此，这为我们提供了11 * 10 * 9 * 8 * 7 = 55440个解决方案，每个解决方案的长度均为106个字节。

05AB1E，102 90 89 69字节（EOIXC）

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

在线尝试！

输出（230字节）：

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％压缩

说明：

理论是挑选垂直对称的字母，然后对前3行进行编码，以使它们回文。基本上，我在2个字节对​​中编码为{Letter}的{＃}。我敢肯定有更好的方法可以做到这一点。

•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字节，感谢Emigna，我将在聊天中很快提一些问题;）。

JavaScript ES6，168个字节，CHAMP

我们不能再找人了，我们CHAMP在这边

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字节

更好的重做：

这在优化磁带，牺牲用于打印字符的设置字符方面做得更好。该磁带看起来像一样'C' 'E' ' ' 'F' 'I' 'L' '\n'，提高了效率。我之所以选择它们，是因为它们缺乏内部空间，因此它们不必在字符和空间之间来回移动

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

如果您想阅读它在做什么，请执行以下操作：

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

输出：

 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

以前的提交：

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

我之所以选择ABCDE，是因为它使设置输出磁带变得更加容易，但是我浪费了时间和字符，从字母到''，用于A，B和D内的所有负数空间以及我想，磁带结尾处的终端线有点杀了我。

我最终得到了一个带有值的磁带，0 0 'A' 'B' 'C' 'D' 'E' ' ' \n然后从那里输出

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

输出：

 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字节 99字节

精英

在@DrMcMoylex的帮助下，它在100以下打高尔夫球。

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

它包含不可打印的字符，因此我在下面（Vim样式）中添加了它们，以便您可以看到它们。

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

TryItOnline！

它基本上使用与果冻答案相同的行程解码。我使用字母（希望）重复底部的顶部，而中间的3个字母都相同。一旦创建了顶部，底部和中部，就可以编辑字符以使其正确：

1. 在I上添加两个空格（更多信息请参见下文）
2. 在T中添加两个空格
3. 添加E条
4. 取下L的顶部
5. 删除T的底部（并删除2个空格）

我必须在I上加上两个空格，因为我不允许使用两位数字（因此我不需要分隔符。这导致我需要11的9个空格。

MATL，49字节

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

在线尝试！

这产生了字母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

说明

T从头开始构建相对容易。I基本上可以T加上垂直反射就可以得到。H被I换位。N被Z转置并垂直反射。

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字节

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

在线尝试！

输出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个字节（ABCDE）

注意：这包含不可打印的字符，为了便于测试，在此处转义了这些字符xxd。

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

将字母位置的二进制表示形式存储为数字，然后解压缩为二进制，使用查找将0s 替换为空格，将s 替换1为对应的字母。存储字母表示形式非常容易，但是替换它们却比我希望的更加棘手。我相信有更好的方法可以做到这一点，所以我很可能会继续玩下去。

要重新创建文件，请运行xxd -r > favourite-letter.pl，粘贴在下面，然后按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

用法

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字节

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

与我的其他答案类似，但字母选择更好。输出此：

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字节（CKYTF）

资源

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

输出量

  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

在线尝试！

万一重要，我应该指出，我的输出在每行上都有一个前导空格。规则没有明确禁止这样做，所以我希望可以。如果没有，请仅将此视为非竞争条目。

说明

单词的字母被编码为25个整数的简单序列，每个整数都是5个像素的二进制表示形式。由于Befunge要求您执行计算以实例化大于9的任何整数，因此选择字母是为了最大程度地减少所需的计算次数，并且对字母进行了排序，以便可以重复而不是重新计算潜在的重复值。

我们还需要将每个字母的ASCII值（偏移32）存储在一个数组中，该数组由一个递减索引的模5索引（因此它变为0 4 3 2 1 ...）。偏移量为32的原因是，该值可以乘以像素位（1或0），然后加到32以产生空格或所需的字符。

该字母值数组存储在代码的前5个字节中，因此很容易访问。然后，这也影响了字母的选择，因为当将这些值解释为代码序列时，这些值必须有意义。这是顺序#&49+。所述#在跳跃&和49+刚刚推到13随后被忽略堆栈。

红宝石，110个 107 102字节（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

版画

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

编辑：通过避免join和移动周围的东西节省了一些字符

Befunge-98，109个 98字节（FUNGE / ANY）

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

在线尝试！

输入（115个字符）：

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

输入是二进制数字的整数版本，其格式为aaaaabbbbbb其中aaaaa要打印的字符的反向映射（例如，N中的第二行是NN N，因此掩码为10011），并且bbbbbb是要打印的ascii字符，减32 。

我还创建了一个befunge-98程序来创建输入：

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

在线尝试！

输出（255个字符）：

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％压缩

说明：

: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

这可能很不错。我几乎没有花任何时间考虑潜在的减少量。

从理论上讲，这可以打印任何5x5的ascii艺术序列。

感谢James Holderness帮助我摆脱三位数！

C＃，290 279 267 265个字节

编辑：由于@milk，节省了12个字节！还有2个感谢@TheLethalCoder

打高尔夫球：

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

取消高尔夫：

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

输出：

 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 个字节 “ BCDEO”

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

运行并调试

我选了一些信

• 垂直对称
• 其中间三列相同

这些属性意味着每个字母可以由3x3网格表示。这是9个地区，以数字表示。

12223
45556
78889
45556
12223

考虑字母“ B”。可以用3个八进制数字表示656。每个数字包含三个位，这些位控制为该字母启用哪些区域。该技术也适用于“ CDEO”。

该程序在未打包，未打包和注释的情况下看起来像这样。

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

运行这个

Python 3中，234 228 227 166字节（云）：

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

印刷品：

 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个字节

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)

不会赢，但不使用任何压缩。它使得：

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

欢迎任何帮助，我可能错过了一些东西。我没有使用Python 2，因为您无法执行p=print，因此节省了17个字节。在repl.it上尝试。

Ruby，101个字节（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

我选择的字母在每行上需要单个字母块（长1,4或5个字母）。F，L和E左对齐，但T和我需要在前导空格处打印单个字母（垂直部分）。添加这些空格的代码看起来可以改进。

不打高尔夫球

"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字节

如果允许使用隐式整数，则可以再剪掉8个字节。

#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

输出：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     

工作原理：宏R重复一段代码5次。鉴于五一出现在这个问题上的频率，非常有用。现在：这是T（int）的作用。T接受一个整数，并将其用作位字段来确定在哪里打印字母和在哪里打印空白。例如，如果给出T(0b11111111100111111110011100)，它将输出：EEEEE DDDD CCCC BBBB AAA。它会逐步递减打印的字母。首先打印E，然后打印D，然后是C，然后是B，然后是A。调用f（）将打印整个内容。

批处理，135字节（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

注意：第一行以5个空格结束。

重击 95，111字节（EBASH）

打高尔夫球

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

说明

原始LZMA字节流上的Base64

演示版

>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

免责声明

是的，我很清楚这不是真正可移植的，这就是为什么我在第一种情况下用-q来抑制xz警告的原因是花了一个字节> :)

Python 2中，208个 194 193字节

这是我第一次打高尔夫球；）做起来很有趣

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

输出：

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

使用字典会破坏字母的排序顺序，但这不是必须的

perl 94个字节。

第一4个字母（D，O，I，C）被特别选择为具有类似的上部和下部线，中间那些类似。由于没有其他类似的字母，因此我选择“ L”以能够应用相同的算法并添加缺少的4L。

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

通过用\n真正的新行替换代码中的，我节省了一些额外的字节。

结果：

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