Задача на самом деле очень проста. Выберите 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в качестве направления.

Примечание. 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 байт (ОБЛАКО)

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

Это длинное и не очень оптимизированное (по крайней мере, пока), но его можно изменить для печати любого конкретного сообщения, изменяя только растровые данные.

РЕДАКТИРОВАТЬ: заменено внутреннее уменьшение на карту , используйте битовый сдвиг для заполнения

Golfed

[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 с figlet, 55440 решений, 112 106 байт каждый

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

Выход:

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

Эй, у нас уже есть программа для ASCII искусства! Баннер шрифт почти делает работу, за исключением того, что выводит 7x7 письмо. Хм, давайте просто удалим 3-й и 5-й столбцы, а также 2-й и 5-й строки и посмотрим, что это дает ...

Оказывается, многие буквы будут выводиться требуемым образом, а именно, BDEFHJLPTU Z.

Достаточно заменить аргументы первой команды set любой комбинацией этих букв, чтобы все еще получить правильный результат! Следовательно, это дает нам 11 * 10 * 9 * 8 * 7 = 55440 решений, каждое из которых имеет длину 106 байт.

05AB1E , 102 90 89 69 байт (EOIXC)

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

Попробуйте онлайн!

Выход (230 байт):

EEEEE      OOOO     IIIII     X   X      CCCC
E         O    O      I        X X      C    
EEEE      O    O      I         X       C    
E         O    O      I        X X      C    
EEEEE      OOOO     IIIII     X   X      CCCC

69/230 = 70% сжатия

Объяснение:

Теория заключалась в том, чтобы выбирать вертикально симметричные буквы, а затем кодировать первые 3 строки и палиндромизировать их. По сути, я закодирован как {#} of {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 байт, спасибо Эмигне, я скоро буду в чате, чтобы задать несколько вопросов;).

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

TryItOnline!

Он в основном использует тот же декодер длины пробега, что и желейный ответ. Я использовал буквы, где я мог (надеюсь) повторить верхнюю часть снизу, и все середины были бы одинаковыми. После того, как верх, низ и середина созданы, я редактирую символы, чтобы сделать их правильными:

1. Добавьте два пробела к I (подробнее об этом ниже)
2. Добавьте два пробела к T
3. Добавить планку Е
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 пробелами и 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     

Python 2, 124 байта

d,i,o,c,l,s,n='DIOCL \n'
T=d*4+s*6+i*5+s*6+o*3+s*7+c*4+s*5+l
M=d+s*3+d+s*7+i+s*7+o+s*3+o+s*5+c+s*9+l+n
print T+n,M,M,M,T+l*3

Аналогично моему другому ответу , но с лучшим выбором букв. Выводы это:

DDDD      IIIII      OOO       CCCC     L
D   D       I       O   O     C         L
D   D       I       O   O     C         L
D   D       I       O   O     C         L
DDDD      IIIII      OOO       CCCC     LLLL

Befunge, 120 байт (CKYTF)

Источник

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

Выход

  CCCC     K   K     Y   Y     TTTTT     FFFFF
 C         K  K       Y Y        T       F
 C         KKK         Y         T       FFFF
 C         K  K        Y         T       F
  CCCC     K   K       Y         T       F

Попробуйте онлайн!

В случае, если это имеет значение, я должен указать, что мой вывод имеет пробел в каждой строке. Правила явно не запрещают это, поэтому я надеюсь, что все в порядке. Если нет, просто сочтите это неконкурентной записью.

объяснение

Буквы слова кодируются в виде простой последовательности из 25 целых чисел, причем каждое целое число представляет собой двоичное представление из 5 пикселей. Поскольку Befunge требует от вас выполнения вычисления для создания экземпляра любого целого числа больше 9, буквы были выбраны таким образом, чтобы минимизировать количество требуемых вычислений, и упорядочены таким образом, чтобы потенциальные повторяющиеся значения могли дублироваться, а не пересчитываться.

Нам также нужно сохранить значение ASCII каждой буквы со смещением на 32 в массиве, который индексируется по модулю 5 убывающего индекса (поэтому он равен 0 4 3 2 1 ...). Причина смещения на 32 заключается в том, что значение можно умножить на бит пикселя (1 или 0), а затем добавить к 32, чтобы получить требуемый пробел или символ.

Этот массив буквенных значений хранится в первых 5 байтах кода, поэтому к нему легко получить доступ. Это также затем повлияло на выбор букв, так как эти значения должны быть значимыми при интерпретации как последовательность кода. Это последовательность #&49+. В #перепрыгивает &и 49+просто толкает 13 в стек , который впоследствии игнорируется.

Рубин, 110 107 102 байта (DOCIL)

puts a=?D*4+(t=' '*7)+?O*3+t+?C*4+(s=' '*5)+?I*5+s+?L,['D   D'+s+'O   O'+s+?C+' '*11+?I+t+?L]*3,a+?L*4

Печать

DDDD       OOO       CCCC     IIIII     L
D   D     O   O     C           I       L
D   D     O   O     C           I       L
D   D     O   O     C           I       L
DDDD       OOO       CCCC     IIIII     LLLLL

РЕДАКТИРОВАТЬ: сохранить некоторые символы, избегая joinи перемещая вещи

Befunge-98 , 109 98 байт (FUNGE / ANY)

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

Попробуйте онлайн!

Ввод (115 символов):

2022 1141 1134 935 2021 102 1141 1262 103 101 998 1141 1390 1639 997 102 1141 1646 1127 101 102 949 1134 935 2021 0

Ввод - это целочисленная версия двоичного числа с форматом, в aaaaabbbbbbкотором aaaaaэто обратная карта символа для печати (например, вторая строка в N - это NN N, значит, маска 10011), и bbbbbbэто символ ascii для печати, минус 32 ,

Я также создал программу befunge-98 для создания своих входов:

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

Попробуйте онлайн!

Вывод (255 символов):

FFFFF     U   U     N   N      GGG      EEEEE     
F         U   U     NN  N     G         E         
FFFF      U   U     N N N     G  GG     EEEE      
F         U   U     N  NN     G   G     E         
F          UUU      N   N      GGG      EEEEE     

(255 - (115 + 98)) / 255 = 16% сжатия

Объяснение:

:5%!2>j#4_;\$&\#;\:0`!#@_     Get input if it is available, else end program
:::'@/'@*-\'@/2%*' +,         Output the current input character (or a space,
                              if the mask dictates so)
:'@/:2/-'@*-                  Throw away current mask bit
\1+                           Swap loop iterator to top of stack, increment it
:5%!2>j#4_;' *3k:4k,#;        If iterator % 5 == 0, print five spaces
:55*%!2>j#4_;a,;              If iterator % 25 == 0, print newline character

Это, вероятно, довольно играбельно; Я почти не думал о возможных сокращениях.

Теоретически это может напечатать любую последовательность 5x5 ascii art.

Спасибо Джеймсу Холдернсу за помощь в выборе трехзначных цифр!

C #, 290 279 267 265 байт

Изменить: 12 байтов сохранены благодаря @milk! И еще 2 благодаря @TheLethalCoder

Golfed:

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

Запустите и отладьте его

Я выбрал письма, которые

• иметь вертикальную симметрию
• чьи средние три столбца идентичны

Эти свойства означают, что каждая буква может быть представлена ​​сеткой 3х3. Вот 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

Запустите этот

Питон 3, 234 228 227 166 байт (ОБЛАКО):

import base64,gzip;b=b'ABzY86gn$d0{>HR1_A{T@KJyRe}8`nBNU1i6kLFS%Nec$q1YdaQ51tPO;sx(oDBkK&Q=Hwg(wC)8vxUXJX_-c000';print(gzip.decompress(base64.b85decode(b)).decode())

Печать:

 CCCC     L          OOO      U   U     DDDD
C         L         O   O     U   U     D   D
C         L         O   O     U   U     D   D
C         L         O   O     U   U     D   D
 CCCC     LLLLL      OOO       UUU      DDDD

Python 3, 178 байт

e,f,i,t,h,s='EFITH '
p=print
S=s*5
D=i+s*9+t+s*7
A=e*5+S
F=S+i*5+S
B=e+s*9+f+s*11+D+h+s*3+h
C=h+s*3+h
p(A+f*5+F+t*5+S+C)
p(B)
p(e*4+s*6+f*4+s*8+D+h*5)
p(B)
p(A+f+s*4+F,s+t+s*7+C)

Не победит, но не использует сжатие. Это делает это:

EEEEE     FFFFF     IIIII     TTTTT     H   H
E         F           I         T       H   H
EEEE      FFFF        I         T       HHHHH
E         F           I         T       H   H
EEEEE     F         IIIII       T       H   H

Любая помощь приветствуется, я, наверное, что-то пропустил. Я не использовал Python 2, потому что вы не можете сделать p=print, и это экономит 17 байтов. Попробуйте это на repl.it.

Рубин, 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 требуют начальных пробелов, где печатается одна буква (вертикальная часть). Код для добавления этих пробелов выглядит так, как будто его можно улучшить.

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

Если неявные целые числа разрешены, то возможно отрезать еще 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 пробелами.

BASH, 95111 байтов (EBASH)

Golfed

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