Завдання насправді надзвичайно проста. Виберіть 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 букв, які ви хочете, це дозволить повторно використовувати деякий код і знизити кількість байтів. Виявлення, які букви дозволять вам зробити це найбільш ефективно, є частиною завдання.
• Задні проміжки прийнятні.
• Прийнятний єдиний зворотний рядок, хоча не більше одного зворотного рядка.
• Це кодовий гольф, виграє найменший байт.

Приклади:

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”Kż
141D+“ȷɓSɠ’“ðƁ ƥ“JrŀṘ’jḃ11Ç€ŒṙY

СпробуйтеItOnline!

Ідея

Використовуйте декодування довжини пробігу з літерами, які мають максимально подібну середину, лише одна довжина пробігу кожного "піксельного значення" на рядок на кожну букву.

Поставте плоский старт типу "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як індекси Jelly коду сторінки потім ðƁ ƥ, ȷɓ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,'     '

Ідея полягає в тому, щоб збільшити пробіли між літерами, щоб ми могли отримати повторне стиснення.

Взяв на себе відповідь середньої ланки з дедупликацією серед відповідей Флорента . Збережено 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)

Це довго і не дуже оптимізовано (ще не принаймні), але його можна змінити для друку будь-якого конкретного повідомлення, змінивши лише дані растрових зображень.

EDIT: Замінено внутрішнє зменшення на карту , використовуйте бітовий зсув для набивання

Гольф

[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 в відповідь .

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 додані символи в кінці рядка.

Як і у відповіді Флорента , це фрагмент, який повертає результат. Додайте 3 байти, якщо це потрібно для функції.

Фрагмент тесту

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

Bash + coreutils з філе, 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  
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 рядки паліндромізувати їх. В основному, я закодований як {#} {{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 байт завдяки Еміньї, я незабаром буду в чаті, щоб задати кілька питань;).

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 байт

ELITC

Гольфував його під 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

СпробуйтеItOnline!

В основному він використовує той же декодування довжини пробігу, що і відповідь желе. Я використав букви, де я міг би (сподіваюсь) повторити верх на нижній частині, і середні всі 3 були б однаковими. Як тільки вершини, днища та середні створені, я редагую символи, щоб зробити їх правильними:

1. Додайте два пробіли до I (докладніше про це нижче)
2. Додайте до пробілу два пробіли
3. Додайте смугу E
4. Зніміть верхню частину L
5. Видаліть нижню частину Т (і видаліть 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 пробілами та 1s відповідною буквою, використовуючи пошук. Збереження буквених зображень досить просто, але замінити їх виявилося складніше, ніж я сподівався. Я впевнений, що є кращі способи зробити це, щоб я міг продовжувати грати з цим.

Щоб відтворити файл, запустіть 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     

Пітон 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

EDIT: Збережено деякі характеристики, уникаючи 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.

Дякую Джеймсу Холдерсу за допомогу мені вийти з тризначних цифр!

C #, 290 279 267 265 байт

Редагувати: Збережено 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"));}

Безумовно:

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

Розгляньте букву "В". Вона може бути представлена ​​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

Пітон 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 і I потрібні пробіли, де друкується одна буква (вертикальна частина). Код для додавання цих пробілів виглядає так, що його можна було б покращити.

неозорий

"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

Пояснення

Base64 над сирим потоком байтів LZMA

Демо

>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