ความท้าทายนั้นง่ายมากจริง ๆ เลือกตัวอักษรที่แตกต่างกัน 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 ตัวอักษรเดียวกันไม่ได้รับอนุญาตไม่มีตัวเลือกซ้ำ
• ตัวอักษรแต่ละตัวจะต้องใช้ทุนของตัวเองเป็นตัวละคร ASCII เพื่อวาด
• เอาต์พุตตัวอักษรแต่ละตัวจะต้องอยู่ใน "บรรทัดเดียวกัน" และมีช่องว่าง 5 ช่องระหว่างตัวอักษรแต่ละตัว
• คุณอาจเลือกใดตัวอักษร 5 ที่คุณต้องการนี้จะช่วยให้คุณสามารถนำมาใช้ใหม่รหัสบางอย่างและลดจำนวนไบต์ของคุณ การพิจารณาว่าตัวอักษรใดที่จะช่วยให้คุณทำสิ่งนี้ได้อย่างมีประสิทธิภาพมากที่สุดคือส่วนหนึ่งของความท้าทาย
• ช่องว่างต่อท้ายเป็นที่ยอมรับ
• ขึ้นบรรทัดใหม่ต่อท้ายหนึ่งบรรทัดยอมรับได้ไม่เกินหนึ่งบรรทัดขึ้นบรรทัดใหม่แม้ว่า
• นี่คือรหัส - กอล์ฟชนะน้อยที่สุดนับไบต์

ตัวอย่าง:

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    

บ้า

 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

“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เป็นทิศทาง

หมายเหตุ: รูปหลายเหลี่ยมตามเพียงวาดส่วนที่ระบุโดยไม่ต้องเติมรูปหลายเหลี่ยมหรือเติม รูปหลายเหลี่ยมจะเสร็จสมบูรณ์และเติม (ไม่ใช่สิ่งที่เราต้องการ) หากรูปหลายเหลี่ยมสามารถเติมเต็มด้วยเส้นอย่างง่ายในหนึ่งในแปดทิศทางที่สำคัญหรือ intercardinal มิฉะนั้นจะทำงานเหมือน 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 ที่บันทึกไว้ 6 ไบต์ต้องขอบคุณเบนโอเว่นโดยใช้สตริงคูณสำหรับตรงกลางแถวที่สามและไบต์เพิ่มเติมขอบคุณที่แมตต์

การส่งออกเป็นเหมือนดังต่อไปนี้ที่ 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 ไบต์ (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))
)

ผลลัพธ์คือ 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)

อันนี้ยาวและยังไม่ได้รับการปรับให้เหมาะสมจริงๆ (อย่างน้อยยังไม่ได้) แต่สามารถปรับเปลี่ยนเพื่อพิมพ์ข้อความใด ๆ โดยการเปลี่ยนข้อมูลบิตแมปเท่านั้น

แก้ไข:แทนที่ลดภายในด้วยแผนที่ใช้บิตกะสำหรับการขยาย

แข็งแรงเล่นกอล์ฟ

[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 ตัวสแกนบรรทัดโดยใช้ "top" 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 ของ คำตอบ

ECOIH

‘ÓÑ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)))

Bash + coreutils พร้อม figlet, 55440 solution, 112 106 bytes

 set H E L P D;for l;do figlet -f banner $l|sed "s/.//3;s/.//5;s/#/$l/g;2d;5d">$l;done;paste $@|expand -t10

เอาท์พุท:

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

เฮ้เรามีโปรแกรมสำหรับงานศิลปะ ASCII แล้ว! แบนเนอร์อักษรเกือบจะทำงานยกเว้นมันจะออกผลลัพธ์ตัวอักษร 7x7 อืมเรามาลบคอลัมน์ที่ 3 และ 5 และบรรทัดที่ 2 และ 5 แล้วดูว่ามันให้อะไร ...

ปรากฎว่าตัวอักษรจำนวนมากจะถูกส่งออกในวิธีที่จำเป็นคือ BDEFHJLPTU Z

มันพอเพียงที่จะแทนที่ข้อโต้แย้งของคำสั่งชุดแรกด้วยการรวมกันของตัวอักษรเหล่านั้นเพื่อให้ได้ผลลัพธ์ที่ถูกต้อง! ด้วยเหตุนี้สิ่งนี้จึงทำให้เรามี 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 บรรทัดแรกที่ palindromize โดยพื้นฐานแล้วฉันเข้ารหัสเป็น {#} ของ {Letter} เป็น 2 ไบต์ ฉันแน่ใจว่ามีวิธีที่ดีกว่าในการทำเช่นนี้

•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

เป็นกลุ่ม116 ไบต์ 99 ไบต์

ELITC

Golfed มันต่ำกว่า 100 ด้วยความช่วยเหลือของ @DrMcMoylex

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!

โดยพื้นฐานแล้วมันใช้การถอดรหัสความยาวรันเดียวกับที่คำตอบของเยลลี่ทำ ฉันใช้ตัวอักษรที่ฉันสามารถ (หวังว่า) ซ้ำด้านบนด้านล่างและ middles จะทั้ง 3 เหมือนกัน เมื่อสร้าง tops, bottoms และ middles แล้วฉันจะแก้ไขตัวละครเพื่อแก้ไขให้ถูกต้อง:

1. เพิ่มช่องว่างสองช่องลงใน I (เพิ่มเติมด้านล่าง)
2. เพิ่มสองช่องว่างใน T
3. เพิ่มแถบของ E
4. นำส่วนบนของ L ออก
5. ลบด้านล่างของ T (และลบ 2 ช่องว่าง)

ฉันต้องเพิ่มช่องว่างสองช่องลงใน I เพราะฉันไม่อนุญาตให้มีตัวเลขสองหลัก (ดังนั้นฉันจึงไม่จำเป็นต้องมีตัวคั่นซึ่งจะทำให้มีช่องว่าง 9 ช่องที่ฉันต้องการ 11

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 ด้วยช่องว่างและ1 s ด้วยตัวอักษรที่สอดคล้องกันโดยใช้การค้นหา การจัดเก็บการแสดงตัวอักษรนั้นค่อนข้างง่าย แต่การแทนที่มันกลับกลายเป็นเรื่องยุ่งยากมากกว่าที่ฉันคาดไว้ ฉันแน่ใจว่ามีวิธีที่ดีกว่าในการทำเช่นนี้ดังนั้นฉันอาจเล่นกับสิ่งนี้ต่อไป

หากต้องการสร้างไฟล์ขึ้นใหม่ให้เรียกใช้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 บนสแต็คที่จะถูกละเว้นภายหลัง

Ruby, 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 bytes (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 art ใด ๆ

ขอบคุณJames Holderness ที่ช่วยฉันออกจากตัวเลขสามหลัก!

C #, 290 279 267 265 Bytes

แก้ไข: บันทึก 12 ไบต์ขอบคุณ @milk! และอีก 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"));}

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

ขาออก:

 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 ไบต์ (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())

พิมพ์:

 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 และฉันต้องการช่องว่างนำหน้าซึ่งพิมพ์ตัวอักษรเดียว (ส่วนแนวตั้ง) รหัสสำหรับการเพิ่มช่องว่างเหล่านี้ดูเหมือนจะปรับปรุงได้

ungolfed

"o@h@u".bytes{|i|               #for each byte (64 always set, 32...2 bits set for horiz bar, 1 bit=length of bar)
   k=3+i%2                      #decode least sig. bit for no of chars printed if a 1 is found
   puts "%-10s"*5%              #puts "%-10s%-10s%-10s%-10s%-10s" format string (expects array of subsitutes)
     "TIFLE".chars.map{|j|      #for each letter 
        i/=2                    #halve i
        (i/16>i%2*3?'  ':'')+   #if i large enough and i%2 zero, add leading space (or T and I)
        j+j*k*(i%2)             #print the letter once, then additional letters if bar required.
     }
}

C 176 ไบต์

หากอนุญาตให้ใช้ ints โดยนัยก็เป็นไปได้ที่จะตัดอีก 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

คำอธิบาย

Base64 ผ่านสตรีมไบต์ LZMA แบบ raw

การสาธิต

>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

คำปฏิเสธ

ใช่ฉันทราบดีว่านี่ไม่ใช่การพกพาจริงๆนั่นเป็นเหตุผลที่ฉันจ่ายไบต์เพื่อระงับคำเตือนxzด้วย-qในกรณีแรก> :)

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