Thử thách thực sự vô cùng đơn giản. Chọn 5 chữ cái riêng biệt (bạn chỉ có thể chọn 5 chữ cái cho phép bạn mã ngắn nhất nếu bạn muốn) và xuất chúng ra bàn điều khiển. Tuy nhiên, vấn đề là họ phải từ danh sách sau:

 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

Quy tắc bổ sung:

• 5 của cùng một chữ cái không được phép, không có lựa chọn lặp lại.
• Mỗi chữ cái phải sử dụng vốn của chính nó làm ký tự ascii để vẽ nó.
• Mỗi đầu ra chữ cái phải nằm trên "cùng một dòng" và có 5 khoảng cách giữa mỗi chữ cái.
• Bạn có thể chọn bất kỳ 5 chữ cái mà bạn muốn, điều này sẽ cho phép bạn sử dụng lại một số mã và giảm số byte của bạn. Tìm ra những chữ cái sẽ cho phép bạn làm điều này một cách hiệu quả nhất là một phần của thách thức.
• Không gian lưu trữ được chấp nhận.
• Một dòng mới duy nhất được chấp nhận, mặc dù không nhiều hơn một dòng mới.
• Đây là môn đánh gôn, đánh số byte thấp nhất.

Ví dụ:

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    

KHÙNG

 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  

Đừng ngại gửi nhiều hơn một câu trả lời với các chữ cái khác nhau hoặc các chiến lược khác nhau mỗi lần, điều này có thể được thực hiện theo nhiều cách khác nhau.

Thạch , 41 byte

GIẤY PHÉP

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

Dùng thử trực tuyến!

Ý tưởng

Sử dụng giải mã độ dài chạy với các chữ cái có càng giống nhau càng tốt với chỉ một chiều dài chạy của mỗi "giá trị pixel" trên mỗi hàng trên mỗi chữ cái.

Đặt một khởi đầu phẳng như "L" để tránh các giá trị giải mã chiều dài chạy khác nhau cho các hàng.

Đặt một chữ cái khác nhau (không thể tìm thấy 5) của ba hàng giữa ở cuối để sự khác biệt nhỏ nhất có thể được thêm vào một cách hợp lý.

Đầu ra muốn; chiều dài chạy; và những thứ này được chuyển đổi từ cơ sở 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

Ba giá trị 399633415, 431646160và 1179122455ở cơ sở 250như Jelly chỉ số trang mã này sau đó được ðƁ ƥ, ȷɓSɠvà JrŀṘcó thể được sử dụng để đóng gói các thông tin chạy dài.

Mật mã

“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

Than , 51 49 byte (ECXKI)

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

Đầu ra

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

Hãy thử trực tuyến!

Sử dụng các ký tự đối xứng theo chiều dọc, vẽ các nửa trên cùng và sau đó phản ánh. Hầu hết trong số này sử dụng Polygon ( Ｇ) và PolygonHollow ( ＧＨ) để vẽ một loạt các phân đoạn dòng được kết nối với một ký tự cụ thể. Icó thể dễ dàng thực hiện hơn với MultiPrint ( Ｐ), sử dụng Tlàm hướng.

Lưu ý: PolygonHollow chỉ vẽ các phân đoạn được chỉ định, mà không hoàn thành đa giác hoặc điền vào nó. Đa giác sẽ hoàn thành và điền vào (không phải những gì chúng ta muốn) nếu đa giác có thể được hoàn thành với một đường đơn giản theo một trong tám hướng chính hoặc liên thông. Mặt khác, nó hoạt động như PolygonHollow, để tiết kiệm một byte.

Thứ tự của các ký tự được chọn để chỉ yêu cầu di chuyển ngang từ điểm cuối của điểm này đến điểm bắt đầu tiếp theo. Đây là cách con trỏ tiến hành:

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

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

Ý tưởng là tối đa hóa khoảng trắng giữa các chữ cái để chúng ta có thể nén lại nhiều lần.

Mượn mánh lừa đảo hàng giữa từ câu trả lời của Florent . Đã lưu 6 byte nhờ Ben Owen bằng cách sử dụng phép nhân chuỗi cho ba hàng giữa và một byte bổ sung nhờ Matt .

Đầu ra giống như sau với 227 byte, giảm 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 byte (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))
)

Đầu ra là 227 byte:

 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 byte (IGOLF / BẤT K))

Cái này dài và không thực sự được tối ưu hóa (ít nhất là chưa), nhưng có thể được sửa đổi để in bất kỳ thông điệp cụ thể nào, chỉ bằng cách thay đổi dữ liệu bitmap.

EDIT: Thay thế giảm bên trong bằng bản đồ , sử dụng dịch chuyển bit để đệm

Chơi gô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`

Bản giới thiệu

[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         

Học thuyết

Lấy một lá thư:

IIIII      
  I        
  I        
  I        
IIIII 

chuyển đổi nó thành ma trận nhị phân (bitmap)

11111
00100
00100
00100
11111

làm tương tự cho 4 chữ cái khác, quét một dòng, bằng cách lấy 5 bit trên cùng

1111 01110 01110 10000 111111

chuyển đổi thành chuỗi thập lục phân (nên sử dụng cơ sở36 hoặc thậm chí có thể in ASCII tại đây)

0x1f73a1f

áp dụng thuật toán tương tự cho 4 dòng khác, để có được bitmap.

Kết xuất theo thứ tự ngược lại.

PHP, 107 104 102 94 86 byte

Ok tôi tự tin tôi có nguồn nhỏ nhất có thể với phương pháp này bây giờ. Tôi đã viết một tập lệnh để tạo và sau đó gzip mọi kết hợp có thể có của năm chữ cái. Có hai giải pháp phù hợp với nén ngắn nhất - LODIC và LDOIC. Tôi đang đi với người trước vì nói vui hơn.

Nguồn:

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

Đầu ra:

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

Đây là một niềm vui.
Tôi cảm thấy mình cần phải quay lại và thử chơi golf thêm một chút nữa khi có thời gian.

Sử dụng mã hóa CP-1252 .
Lấy cảm hứng từ câu trả lời của carusocomputing .

Sinh thái

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

Hãy thử trực tuyến!

Giải trình

‘ÓÑOIHH‘đẩy chuỗi "ECOOIHH".

SðýJ3×Snối chuỗi bằng dấu cách, lặp lại ba lần và chuyển đổi nó thành một danh sách.
Danh sách kết quả là ['E', ' ', 'C', ' ', 'O', ' ', 'O', ' ', 'I', ' ', 'H', ' ', 'H', 'E', ' ', 'C', ' ', 'O', ' ', 'O', ' ', 'I', ' ', 'H', ' ', 'H', 'E', ' ', 'C', ' ', 'O', ' ', 'O', ' ', 'I', ' ', 'H', ' ', 'H'].

•Td<UÕ‘áÓ?¢tWvkÔÚ•đẩy số 564631055513119191317171314619131717500.

S)ø zips danh sách và số cùng nhau.

ü×Jkhông lặp lại chuỗi đôi và nối chúng lại với nhau.
Kết quả là chuỗi EEEEE CCCC OOO IIIII H HE C O O I H HEEEE C O O I HHHHH.

3äû»chia nó thành 3 mảnh, thêm mảnh thứ nhất và thứ hai theo thứ tự ngược lại và tham gia theo dòng mới.

JavaScript (ES6), 96 byte (DIOCL)

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

Ý tưởng ở đây là không chỉ làm cho ba dòng giữa giống hệt nhau, mà còn làm cho dòng đầu tiên gần giống với dòng cuối cùng. Vì chỉ có 4 chữ cái hoàn toàn phù hợp với mô tả nàyCDIO , Llà tùy chọn tốt nhất tiếp theo, vì nó chỉ yêu cầu 4 ký tự được thêm vào cuối chuỗi.

Như với câu trả lời của Florent , đây là đoạn trích trả về kết quả. Thêm 3 byte nếu nó cần là một hàm.

Kiểm tra đoạn

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

Bash + coreutils với figlet, 55440 giải pháp, mỗi 112 106 byte

 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

Đầu ra:

HH EEEEE L PPPP DDDĐ  
HHELPPDĐ 
HHHHH EEEE L PPPP DD 
HHELPDĐ 
HH EEEEE LLLLL P DDDĐ  
                                              

Này, chúng tôi đã có một chương trình cho nghệ thuật ASCII! các biểu ngữ phông chữ gần như không được công việc, ngoại trừ nó ra chữ 7x7. Hmm, hãy xóa các cột thứ 3 và thứ 5, dòng thứ 2 và thứ 5, và xem những gì nó mang lại ...

Nó chỉ ra rằng nhiều chữ cái sẽ được xuất theo cách yêu cầu, cụ thể là, BDEFHJLPTU Z.

Nó đủ để thay thế các đối số của lệnh set đầu tiên bằng bất kỳ sự kết hợp nào của các chữ cái đó để vẫn có được kết quả chính xác! Do đó, điều này mang lại cho chúng ta các giải pháp 11 * 10 * 9 * 8 * 7 = 55440, mỗi giải pháp dài 106 byte.

05AB1E , 102 90 89 69 byte (EOIXC)

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

Hãy thử trực tuyến!

Đầu ra (230 byte):

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% nén

Giải trình:

Lý thuyết là chọn các chữ cái đối xứng theo chiều dọc, sau đó mã hóa 3 dòng đầu tiên để xác định lại chúng. Về cơ bản, tôi đã mã hóa thành {#} của {Letter} theo cặp 2 byte. Tôi chắc chắn có một cách tốt hơn để làm điều này.

•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 byte nhờ Emigna, tôi sẽ sớm trò chuyện để hỏi một số câu hỏi;).

JavaScript ES6, 168 byte, CHAMP

Chúng ta có thể ngừng tìm kiếm các chàng trai, chúng ta có một CHAMPở đây

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 byte

Làm lại tốt hơn:

Cái này làm tốt hơn trong việc tối ưu hóa băng, hy sinh các ký tự thiết lập để in các ký tự. Các băng trong này trông giống như 'C' 'E' ' ' 'F' 'I' 'L' '\n', nâng cao hiệu quả. Tôi đã chọn những thứ này vì chúng thiếu không gian bên trong, khiến chúng không phải qua lại giữa nhân vật và không gian nhiều hơn mức cần thiết

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

Nếu bạn muốn đọc những gì nó đang làm:

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

Đầu ra:

 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

Đệ trình cũ:

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

Tôi đã chọn sử dụng ABCDE vì nó giúp việc thiết lập băng cho đầu ra dễ dàng hơn nhiều, nhưng thời gian và ký tự tôi đã lãng phí khi chuyển từ chữ cái sang '' cho tất cả không gian âm bên trong A, B và D và vị trí của phần cuối của đoạn băng đã giết tôi, tôi nghĩ vậy.

Tôi đã kết thúc với một băng có các giá trị 0 0 'A' 'B' 'C' 'D' 'E' ' ' \nvà sau đó xuất ra từ đó

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

Đầu ra:

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

ELITC

Chơi gôn dưới 100 với sự giúp đỡ của @DrMcMoylex.

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

Điều này chứa các ký tự không thể in được, vì vậy tôi đã thêm chúng vào bên dưới (kiểu Vim), để bạn có thể nhìn thấy chúng.

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

Dùng thử trực tuyến!

Về cơ bản, nó sử dụng cùng một giải mã độ dài chạy mà câu trả lời thạch thực hiện. Tôi đã sử dụng các chữ cái mà tôi có thể (hy vọng) lặp lại từ trên xuống dưới và các câu đố sẽ có cả 3 giống nhau. Khi đỉnh, đáy và câu đố được tạo, tôi chỉnh sửa các ký tự để làm cho chúng chính xác:

1. Thêm hai khoảng trắng vào chữ I (nhiều hơn ở bên dưới)
2. Thêm hai khoảng trắng vào T
3. Thêm thanh của E
4. Loại bỏ đỉnh L
5. Xóa phần dưới của chữ T (và xóa 2 khoảng trắng)

Tôi phải thêm hai khoảng trắng vào I, vì tôi không cho phép hai số có chữ số (vì vậy tôi sẽ không cần dấu phân cách. Điều này dẫn đến một khoảng trống 9 nơi tôi cần 11.

MATL , 49 byte

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

Hãy thử trực tuyến!

Điều này tạo ra các chữ cái 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

Giải trình

Tlà tương đối dễ dàng để xây dựng từ đầu. Ivề cơ bản có thể thu được như Tcộng với phản xạ dọc của nó. Hđược Ihoán vị. Nđược Zhoán vị và phản xạ theo chiều dọc.

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 byte

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

Hãy thử trực tuyến!

Kết quả này 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 byte (ABCDE)

Lưu ý : phần này chứa các ký tự không thể in được, đã thoát để dễ kiểm tra tại đây, xxdkết xuất bên dưới.

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

Lưu trữ biểu diễn nhị phân của các vị trí chữ cái dưới dạng số, sau đó giải nén trở lại thành nhị phân, thay thế 0s bằng dấu cách và1 s bằng chữ cái tương ứng, sử dụng tra cứu. Lưu trữ các đại diện thư là khá dễ dàng, nhưng thay thế chúng hóa ra khó khăn hơn tôi mong đợi. Tôi chắc chắn có nhiều cách tốt hơn để làm điều này vì vậy tôi có thể tiếp tục chơi với nó.

Để tạo lại tệp, chạy xxd -r > favourite-letter.pl, dán vào bên dưới và nhấn 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

Sử dụng

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 byte

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

Tương tự như câu trả lời khác của tôi , nhưng với lựa chọn thư tốt hơn. Đầu ra này:

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

Nguồn

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

Đầu ra

  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

Hãy thử trực tuyến!

Trong trường hợp có vấn đề, tôi nên chỉ ra rằng đầu ra của tôi có một không gian hàng đầu trên mỗi dòng. Các quy tắc không rõ ràng cấm điều đó, vì vậy tôi hy vọng điều đó ổn. Nếu không, xin vui lòng chỉ coi đây là một mục không cạnh tranh.

Giải trình

Các chữ cái của từ được mã hóa thành một chuỗi đơn giản gồm 25 số nguyên, mỗi số nguyên là một biểu diễn nhị phân 5 pixel. Vì Befunge yêu cầu bạn thực hiện phép tính để khởi tạo bất kỳ số nguyên nào lớn hơn 9, các chữ cái đã được chọn để giảm thiểu số lượng tính toán cần thiết và ra lệnh sao cho các giá trị lặp lại tiềm năng có thể được nhân đôi thay vì tính toán lại.

Chúng ta cũng cần lưu trữ giá trị ASCII của mỗi chữ cái, bù 32, trong một mảng được lập chỉ mục bởi modulo 5 của một chỉ số giảm dần (vì vậy nó đi 0 4 3 2 1 ...). Lý do bù đắp cho 32 là vì vậy giá trị có thể được nhân với một bit pixel (1 hoặc 0) và sau đó được thêm vào 32 để tạo khoảng trắng hoặc ký tự được yêu cầu.

Mảng giá trị chữ này được lưu trữ trong 5 byte đầu tiên của mã, vì vậy thật dễ dàng để truy cập. Điều này sau đó cũng ảnh hưởng đến việc lựa chọn các chữ cái, vì các giá trị đó cần có ý nghĩa khi được hiểu là một chuỗi mã. Đây là trình tự #&49+. Các #bước nhảy qua &và 49+chỉ cần đẩy 13 vào stack mà sau đó được bỏ qua.

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

Bản in

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: Đã lưu một số ký tự bằng cách tránh joinvà di chuyển mọi thứ xung quanh

Befunge-98 , 109 98 byte (FUNGE / BẤT K))

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

Hãy thử trực tuyến!

Đầu vào (115 ký tự):

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 là phiên bản nguyên của một số nhị phân với các định dạng aaaaabbbbbbmà aaaaalà một bản đồ đảo ngược của nhân vật để in (ví dụ, hàng thứ hai trong N là NN N, vì vậy mặt nạ là10011 ), và bbbbbblà nhân vật ascii để in, trừ đi 32 .

Tôi cũng đã tạo một chương trình befunge-98 để tạo đầu vào của mình:

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

Hãy thử trực tuyến!

Đầu ra (255 ký tự):

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% nén

Giải trình:

: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

Điều này có lẽ là khá golf; Tôi đã dành hầu như không có thời gian suy nghĩ về việc giảm tiềm năng.

Về mặt lý thuyết điều này có thể in bất kỳ chuỗi nghệ thuật ascii 5x5.

Cảm ơn James Holdiness đã giúp tôi thoát khỏi ba chữ số!

C #, 290 279 267 265 byte

Chỉnh sửa: Đã lưu 12 byte nhờ @milk! Và 2 lời cảm ơn nữa đến @TheLethalCoder

Chơi gôn

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

Ung dung:

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

Đầu ra:

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

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

Chạy và gỡ lỗi nó

Tôi đã chọn thư

• có đối xứng dọc
• có ba cột giữa giống hệt nhau

Các thuộc tính này có nghĩa là mỗi chữ cái có thể được biểu thị bằng lưới 3x3. Dưới đây là 9 vùng, được biểu thị bằng chữ số.

12223
45556
78889
45556
12223

Hãy xem xét chữ "B". Nó có thể được biểu thị bằng 3 chữ số bát phân : 656. Mỗi chữ số chứa ba bit, điều khiển vùng nào được bật cho chữ cái đó. Kỹ thuật này cũng hoạt động cho "CDEO".

Giải nén, không ghi chú và nhận xét, chương trình trông như thế này.

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

Chạy cái này

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

Bản in:

 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 byte

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)

Không giành chiến thắng, nhưng không sử dụng bất kỳ nén. Nó làm cho điều này:

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

Bất kỳ trợ giúp đều được chào đón, tôi có thể bỏ lỡ một cái gì đó. Tôi đã không sử dụng Python 2 vì bạn không thể làm điều p=printđó và tiết kiệm 17 byte. Hãy thử nó trên repl.it.

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

Tôi đã chọn các chữ cái yêu cầu một khối chữ cái duy nhất (dài 1,4 hoặc 5 chữ cái) trên mỗi dòng. F, L và E được để lại hợp lý, nhưng T và tôi yêu cầu các khoảng trắng ở đầu in một chữ cái (phần dọc) được in. Mã để thêm các không gian này có vẻ như có thể được cải thiện.

vô dụng

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

Nếu ints ngầm được cho phép thì có thể cắt thêm 8 byte.

#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

Đầu ra: EDCBA

EEEEE     DDDD       CCCC     BBBB       AAA      
E         D   D     C         B   B     A   A     
EEEEE     D   D     C         BBBB      AAAAA     
E         D   D     C         B   B     A   A     
EEEEE     DDDD       CCCC     BBBB      A   A     

Cách thức hoạt động: Macro R chỉ lặp lại một đoạn mã 5 lần. Đưa ra mức độ thường xuyên xuất hiện trong vấn đề này, rất hữu ích. Bây giờ: đây là những gì T (int) làm. T lấy một số nguyên và sử dụng nó làm trường bit để xác định nơi in chữ và nơi in khoảng trắng. Ví dụ: nếu được cung cấp T(0b11111111100111111110011100), nó sẽ xuất ra : EEEEE DDDD CCCC BBBB AAA. Nó dần dần đếm ngược đến những gì nó in chữ. Đầu tiên nó in E, rồi D, rồi C, rồi B, sau đó A. Gọi f () sẽ in toàn bộ.

Batch, 135 byte (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

Lưu ý: dòng đầu tiên kết thúc trong 5 khoảng trắng.

BASH 95, 111 byte (EBASH)

Chơi gôn

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

Giải trình

Base64 qua luồng byte LZMA thô

Bản giới thiệu

>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

Khước từ

Vâng, tôi biết rõ rằng điều này không thực sự di động, đó là lý do tại sao tôi đã trả một byte để loại bỏ các cảnh báo xz với -q trong trường hợp đầu tiên> :)

Python 2, 208 194 193 byte

Đây là môn đánh gôn đầu tiên của tôi;)

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

Đầu ra:

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

Sử dụng từ điển sẽ phá hủy thứ tự sắp xếp của các chữ cái, nhưng đó không phải là một yêu cầu

perl 94 byte.

4 chữ cái đầu tiên ( D, O, I, C) đều được đặc biệt lựa chọn để có các dòng trên và dưới tương tự, và những người trung lưu tương tự. Vì không có bất kỳ chữ cái tương tự nào khác, tôi đã chọn "L" để có thể áp dụng cùng một thuật toán và thêm 4L bị thiếu.

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

Tôi đã lưu một số byte bổ sung bằng cách thay thế \nmã trong một dòng thực sự mới.

Kết quả:

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