5 любимых писем

90

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

Не бойтесь каждый раз отправлять более одного ответа с разными буквами или разными стратегиями, это можно сделать разными способами.

code-golf ascii-art kolmogorov-complexity Урна волшебного осьминога
источник
21
Мне нравится, что вы можете выбирать, какие буквы выводить; это добавляет еще один слой в гольф. Небольшие проблемы с искусством ASCII: есть тонна пробелов и два Jс.
ETHproductions
2
Можете ли вы добавить бонус за получение 5 букв в качестве ввода?
Мукул Кумар
5
Бонусы не одобряются, и ответов на них слишком много, чтобы сделать такие радикальные изменения. Но я дам вам голос;).
Волшебная Урна Осьминога
1
@ Я не знаю, зачем они тебе нужны; трейлинг имеет больше смысла. Если вы можете логически объяснить, как ограничение языка, который вы используете, а не логика, которую вы написали, вызывает лидирующие позиции \n, я позволю это.
Волшебная Урна Осьминога
1
@ Титус тогда нет. Конечные символы новой строки и пробелы происходят из-за программных ограничений некоторых языков.
Волшебная Урна Осьминога

Ответы:

12

Желе , 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
Джонатан Аллан
источник
1
Вы изначально подумали, что я не достаточно умен, чтобы делать это в 05AB1E !!! Удивительная работа человека.
Волшебная Урна Осьминога
32

Древесный уголь , 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 для экономии одного байта.

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

Движение курсора, рисование верхних половин ECXKI

DLosc
источник
2
Приятно. Я пробовал древесный уголь, но нехватка документации честно убила меня
Bassdrop Cumberwubwubwub
6
@Bassdrop Да, мы ... хм ... работаем над этим. [идет, чтобы добавить ＧＨв документы]
DLosc
19

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
AdmBorkBork
источник
Мне нравится, когда первый ответ - это то, чего ты совсем не ожидал. Аккуратный метод.
Волшебная урна осьминога
2
Как насчет $("L11 I1 C11 T1 D D`n"*3)вместо средних 3-х строк
Бен Оуэн
@BenOwen Отличная идея - спасибо!
AdmBorkBork
13

JavaScript, 110 109 байт (ОБЛАКО)

` 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
Флоран
источник
1
Приятно использовать дедупликацию в средних трех рядах.
AdmBorkBork
12

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

Визуализация в обратном порядке.

дирижабль
источник
1
Вы можете удалить скобки в регулярном выражении, чтобы сохранить 2 байта :-)
ETHproductions
1
[32979487,4736528,4834846,4769296,32979952] короче своего шестнадцатеричного представления
Флорент
@ETHproductions Правда, воспользуюсь этим, когда я вернусь, чтобы оптимизировать его. Спасибо!
Цеппелин
1
Вы можете заменить /(1|0)/gна, /\d/gчтобы сохранить несколько байтов. Также \nможет быть заменено актуальной новой строкой.
Флоран
> короче его шестнадцатеричного представления Yep, что верно (из-за 0x), по крайней мере для этих конкретных букв, я, вероятно, сожму это в непрерывную шестнадцатеричную (или даже Base32 / Base36 / ASCII) строку на следующей итерации , > Вы можете заменить / (1 | 0) / g на / \ d / g, чтобы сохранить несколько байтов. Также \ n можно заменить на новую строку. Да, спасибо за ваши советы, я воспользуюсь ими, как только вернусь к этому.
Цеппелин
12

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
Алекс Хованский
источник
3
Вы можете сохранить 2 байта, опустив 's: строка будет считаться константой со своим значением.
user59178 15.11.16
Черт, я всегда забываю это делать. :)
Алексей Хованский
Если бы L было вашим последним письмом, вы бы тоже сохранили больше байтов.
Волшебная Урна Осьминога
Хорошая эксплуатация лазейки.
Исмаэль Мигель
2
Творчество субъективно и неизмеримо. Цель задачи - минимизировать размер кода, и это самая короткая запись для языка, не относящегося к гольфу.
Алекс Хованский
10

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 части, добавляет первый и второй кусок в обратном порядке и объединяет их новыми строками.

Emigna
источник
13
« •Td<UÕ‘áÓ?¢tWvkÔÚ•толкает число 564631055513119191317171314619131717500», потому что почему бы и нет ...
geisterfurz007
3
@ geisterfurz007: Точнее, это представление числа base-10 в base-214 :)
Emigna
Так что потенциально, если бы вы могли подняться на более высокую базу, ваша строка стала бы короче?
geisterfurz007
@ geisterfurz007: Если бы мы могли, да. К сожалению 214 это максимум в 05AB1E.
Эминья
3
Вы можете победить желе, я верю в тебя; Осталось 3 байта, ха-ха!
Волшебная Урна Осьминога
9

JavaScript (ES6), 96 байт (DIOCL)

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

Идея здесь состоит в том, чтобы не только сделать средние три строки идентичными, но и сделать первую строку почти идентичной последней. Поскольку есть только 4 буквы, которые идеально подходят под это описание CDIO,L это следующий лучший вариант, так как для него требуется только 4 добавленных символа в конце строки.

Как с ответом Флорента , это фрагмент, который возвращает результат. Добавьте 3 байта, если это должна быть функция.

Тестовый фрагмент

Показать фрагмент кода

ETHproductions
источник
Вы можете сохранить байт, поставив Dпервый.
Нил
@ Нейл Спасибо. Я должен был двигаться Cмимо Iи Oа
ETHproductions
Ах, да, вы не можете получить Iсразу после C, хотя интересно делать это, улучшая мое пакетное решение, по той же причине.
Нил
9

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

Йоанн
источник
1
Моя первая мысль при чтении задания была: «Чтобы решить эту проблему, нужно использовать figlet»
FliiFe
6

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

Урна волшебного осьминога
источник
1
Вы можете сохранить 19 байтов, заменив строку на •Cv¶ÉH&9;´ß{ø‰¿šq3d$µ_©Û¶«K>Ò±sÒ9ÍÊC4ÊÚîòvÅr葾)jM•34B2ð:. Войдите в чат 05AB1E, если у вас есть вопросы по поводу кодировки.
Emigna
1
Также 45ôможет быть 3ä.
Emigna
@Emigna Aне является вертикально симметричным, и ни один не является F. Будете догадываться, что как только вы начнете использовать Gили выше, это разрушит то, о чем вы говорите, верно? Кроме того, с моей методологией сжатия я хотел избежать писем, у которых было более 1 вхождения в строке. Если вы хотите сыграть в эту игру и победить меня, я бы приветствовал этот пример :).
Волшебная Урна Осьминога
Там есть 0в O(центральный ряд, правая сторона)
ETHproductions
1
•Cv¶ÉH&9;´ß{ø‰¿šq3d$µ_©Û¶«K>Ò±sÒ9ÍÊC4ÊÚúNÏŒº9¨gÚSÞ•исправляет тот Oже счетчик байтов.
Emigna
5

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>
Развернуть фрагмент

Bassdrop Cumberwubwubwub
источник
5

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
bioweasel
источник
Вы можете использовать [<]>3 раза, чтобы сохранить 6 байтов.
Джо Кинг
5

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.

nmjcman101
источник
Добро пожаловать в PPCG, хороший ответ :).
Волшебная урна осьминога
Я почти просил у Вима ответа.
Золтан Шмидт
2
Я всегда приветствую Vim. :) Некоторые улучшения я вижу. 1) вам не нужна косая черта в вашей команде замещения. 2) Некоторые полезные синонимы: Yвместо Vy, FIвместо ?I<cr>, {вместо gg, wвместо fl. 3) Если вы используете rвместо R, вы можете удалить <esc>.
DJMcMayhem
5

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
Луис Мендо
источник
4

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
DJMcMayhem
источник
3

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
Дом Гастингс
источник
3

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
nedla2004
источник
3

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 в стек , который впоследствии игнорируется.

Джеймс Холдернесс
источник
Вы запрашиваете целочисленный ввод с помощью &, но ваша программа фактически не принимает ввод ... что происходит?
Брайан Градин
Этот символ пропущен '#'
12Me21
@ 12Me21 Я объяснил причину этого в последнем абзаце.
Джеймс Холдернесс
3

Рубин, 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и перемещая вещи

Ли В.
источник
3

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.

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

Брайан Градин
источник
Чтобы продолжить идею, 48*можно заменить на ' (так как в конце концов это 98) и 88*заменить на '@. Спасибо, что помогли мне выбраться из тройных цифр!
Брайан Градин
3

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
Пит Арден
источник
Был момент, когда я подумал, что ваш код на C имеет длину 290279 байт.
Стивен Х.
1
@StevenH. Такое чувство, что игра в гольф в C # :)
Пит Арден
-12 байт, если вы определите локальную функцию следующим образомFunc<string,string>j=a=>a.Replace("|",g)+"\r\n";
молоко
@ milk Круто, спасибо! :)
Пит Арден
Вам нужен \ r в \ r \ n? Сэкономил бы 2 байта
TheLethalCoder
3

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

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

рекурсивный
источник
2

Питон 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
L3viathan
источник
2

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.

nedla2004
источник
2
Что случилось с этим F?
Разрушаемый Лимон
@DestructibleWatermelon Не знаю, как я это пропустил, но сейчас это исправлено.
Недла2004
Гольф ниже оригинального размера: 160 байт, Python 2
CalculatorFeline
Вместо использования p=printвы можете использовать один printоператор с аргументом kw sep='\n'.
Лука Чити
2

Рубин, 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.
     }
}
Уровень реки St
источник
2

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 () напечатает всю вещь.

Х. Антонио Перес
источник
2

Пакет, 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 пробелами.

Нил
источник
2

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 в первом случае> :)

дирижабль
источник
2

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

Использование словаря разрушает порядок сортировки букв, но это не было обязательным требованием.

Pleiadian
источник
Это может сделать -4, если мы возьмем буквы, которые не используют левый верхний угол. Это приведет к получению 24-битного (вместо 25-битного) числа, которое в шестнадцатеричном формате занимает на одну цифру меньше.
Плеяды
2

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
Адам
источник