Minecraft Зеркальный

51

Это Кэлвин . Просто пытаюсь получить 20 повторений, чтобы этот пользователь мог общаться в чате в чате PPCG Minecraft Server .

Напишите программу или функцию, которая принимает положительное целое число.

Если целое число четное (2, 4, 6, ...), выведите или верните эту точную художественную строку ASCII:

                       __    __   __             __  ___
  /\  /\    |  |\  |  |     /    |  |     /\    |     |
 /  \/  \   |  | \ |  |--  |     |--\    /__\   |--   |
/        \  |  |  \|  |__   \__  |   \  /    \  |     |

Если целое число нечетное (1, 3, 5, ...), выведите или верните эту точную строку ASCII:

                       __    __
\        /  |  |  /|  |     /    |   /  \ __ /  |     |
 \  /\  /   |  | / |  |--  |     |--/    \  /   |--   |
  \/  \/    |  |/  |  |__   \__  |__|     \/    |__  _|_

Вы можете предположить, что ввод всегда является положительным целым числом.

В обоих выходных случаях при желании может быть любое количество конечных пробелов до правого края буквы «Т» в каждой строке и / или один завершающий символ новой строки. Обратите внимание, что между каждой буквой есть два столбца пробелов.

Самый короткий код в байтах побеждает.

code-golf  ascii-art  kolmogorov-complexity 
— Старый чат эстафета
источник
54
Я бы тоже назвал Calvin, если бы я был новым пользователем, ищущим представителя;)
— Geobits
13
@Geobits Это я.
— Увлечения Кэлвина
52
@ Geobits Нет, это я. Я знал, что никто не поддержит, если я открою это на самом деле я.
— Оптимизатор
19
Почему важно, кто его создал? Разве репутация не должна основываться на содержании поста?
— болото
19
@ marsh В теории да. На самом деле люди несовершенны. Это был бы интересный эксперимент, позволяющий пользователю с высоким уровнем репутации создать новую учетную запись, чтобы опубликовать несколько задач, чтобы оценить разницу в приеме.
— Geobits

Ответы:

23

JavaScript (ES6), 343 336 289 267 265 260 байт

Просто для удовольствия ... :) (Спасибо Xufox за то, что он обрезал 46 байт, и побудил меня самостоятельно обрезать еще 37 байт.)

n=>`887141${n%2?`
98/202/05/4|3/29 1 /2|5|
 92/92/30 / 0--2|5|--/492/3|--3|
29/29/40/2013912|1|59/4|12_|_`:`3185121_
2/92/9409205/405/94|5|
 /29/2930 9 0--2|5|--94/193|--3|
/892029013912|392/492|5|`}`.replace(/\d/g,x=>+x?x<2?'__':x<9?' '.repeat(x):'\\':'|  |')

Называется как a(4)или похожий. Попробуйте это здесь:

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

Я сконцентрировал пробел в цепочках цифр от 2до 8(например, 887= 23 пробела). Затем каждая цифра заменяется соответствующим количеством пробелов. 0представляет | |и 1представляет __. В общем, эта программа на 170 байт короче, чем две строки вместе (203 + 227 = 430), так что я счастлив. :)

Изменить: Почему-то, это точно такая же длина, как единственная другая запись в этой точке .... o_o

Изменить 2: Сохраненный некоторое пространство, изменяя n%2<1?для n%2?и замены строк. Также использовался тот факт, что начала двух строк одинаковы, чтобы уменьшить еще 5 байтов.

Правка 3: |2| казалось, выглядела ужасно много, поэтому каждый раз упрощался x, экономя 7 байт. Предложения Xufox отрезали еще 40 байтов.

Редактировать 4: Предложение Xufox заменить \nдействительными переносами строк окупилось, удалив 6 байтов из общего количества. Изменение xк 0и __к 1(вставить злой смех здесь), а затем объединив все (вставка множественного числа Regex здесь), так как он сделал в своей записи, сохраненные дополнительные 16 байт.

Редактировать 5: Поскольку я решил использовать стандарты ES6, я использовал пользовательскую интерполяцию строк шаблона, чтобы сбрить 2 последних байта.

— ETHproductions
источник
1
Это число должно иметь что-то к этому! В дополнение к тому, что это идеальный куб, это :-) Не могу голосовать за ваш ответ, так как я не имею представления о JavaScript ...
— Луис Мендо
1
Как насчет .replace(/\d/g,d=>' '.repeat(d))?
— Себастьян Саймон
1
@ETHproductions Отлично! Теперь вы можете побить мой ответ? Осталось всего 9 байт…;) Кстати, когда я подсчитываю ваши байты, он говорит 289, используя инструмент подсчета gEdit…
— Себастьян Саймон
1
Может быть, использовать строки шаблона, чтобы иметь возможность делать реальные разрывы строк вместо \nсохранения одного байта на разрыв строки?
— Себастьян Саймон
1
Теперь у меня на 2 байта меньше тебя. = P
— Себастьян Саймон
12

Матлаб, 343 341

a=' -/\_|';
if mod(input(''),2)
x='003C00E00E000L0005N5000I000005550I0000I0055N4UVYO26R4004400400U005300UUXO060O060003C00C30CO00IO00UUUS060S5B54000';else
x='0I2000L0000L000E05H50C0000000555000C00C00H554UVYO26R4004400400U000250WUU006O006O0I2002I00O0I0O0C0UUU006S05BT0004';end
disp(a(reshape(dec2base(base2dec(reshape(x,[],7),36),6),4,[])-47))

Номер ввода предоставляется из стандартного ввода.

Образец прогона:

>> a=' -/\_|';
if mod(input(''),2)
x='003C00E00E000L0005N5000I000005550I0000I0055N4UVYO26R4004400400U005300UUXO060O060003C00C30CO00IO00UUUS060S5B54000';else
x='0I2000L0000L000E05H50C0000000555000C00C00H554UVYO26R4004400400U000250WUU006O006O0I2002I00O0I0O0C0UUU006S05BT0004';end
disp(a(reshape(dec2base(base2dec(reshape(x,[],7),36),6),4,[])-47))
1
                       __    __   __             __  ___
  /\  /\    |  |\  |  |     /    |  |     /\    |     | 
 /  \/  \   |  | \ |  |--  |     |--\    /__\   |--   | 
/        \  |  |  \|  |__   \__  |   \  /    \  |     |
— Луис Мендо
источник
1
Это просто безумие, лол. +1.
— rayryeng - Восстановить Монику
1
@rayryeng Да :-) Жаль, что Matlab допускает только базу до 36. Большее значение сэкономило бы немало байтов
— Луис Мендо
1
@LuisMendo Именно то, что я думал, делая свое решение JavaScript ...
— Себастьян Саймон
@Xufox в JS Функции btoa () и atob () имеют кодировку и декодирование base64 соответственно.
— хлопнуть
11

CJam, 158 149 145 138 байт

li2%"A+×rµ^ÅÆÿ»£ºoU#ü T^U^ÝZe<ÄÊKÞÒ£^ÛWWø5Úí§¹T^Úêer^^°^Ã}Ã^A0R2"281b7b"/
 -_\|"f=N/S3**_"_ ":T/TW%*4/zW%1m>N*1>"\/"_W%er"^W^]5OU"{i_32>T=t}/\4/zN*?

Выше используется символ каретки, так как код содержит непечатаемые символы.

Попробуйте онлайн в интерпретаторе CJam .

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

Пример запуска

$ LANG=en_US
$ xxd -ps -r > minecraft.cjam <<< 6c69322522412bd772b585c6ffbba3ba6f5523fc2054159d5a653cc4ca4bded2a39b5757f835daeda7b9549aea65721eb0837dc30130523222323831623762222f0a202d5f5c7c22663d4e2f53332a2a5f225f20223a542f5457252a342f7a5725316d3e4e2a313e225c2f225f5725657222171d354f55227b695f33323e543d747d2f5c342f7a4e2a3f
$ cjam minecraft.cjam <<< 2; echo
                       __    __   __             __  ___
  /\  /\    |  |\  |  |     /    |  |     /\    |     | 
 /  \/  \   |  | \ |  |--  |     |--\    /__\   |--   | 
/        \  |  |  \|  |__   \__  |   \  /    \  |     | 
$ cjam minecraft.cjam <<< 1; echo
                       __    __                        
\        /  |  |  /|  |     /    |   /  \ __ /  |     | 
 \  /\  /   |  | / |  |--  |     |--/    \  /   |--   | 
  \/  \/    |  |/  |  |__   \__  |__|     \/    |__  _|_

идея

Вместо непосредственного кодирования строки MINECRAFT (дополненной для достижения постоянной длины строки), мы закодируем ее «сжатую» версию, в которой строки и столбцы были транспонированы.

После архивирования и удаления перевода строки, эта строка (назовем ее R ) должна быть закодирована:

   /  /  /   \    \   /  /   \    \    \         |||         ||| \    \    \ |||         |||_ -__ -_          |  / \_  __  _         |||_ - _ -  |\    \           /  /  /_  \_   \    \         |||_ - _ -         _   _|||_

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

Это оставляет нам семь различных символов ( \n -/\_|), поэтому мы присваиваем каждому из них число от 0 до 6 и рассматриваем получающиеся в результате цифры массива из базового числа 7, которые мы затем кодируем как байтовую строку.

Декодирование работает путем изменения шагов сверху.

Зеркальная строка может быть построена из оригинальной.

Если мы изменим порядок четырех строк и поменяем местами солидусы, мы получим следующее:

\        /  |  |  /|  |__   /__  |   /  \    /  |     | 
 \  /\  /   |  | / |  |--  |     |--/    \__/   |--   | 
  \/  \/    |  |/  |  |     \    |  |     \/    |     | 
                       __    __   __             __  ___

Как-то похоже, но нам явно придется вращать ряды, чтобы вывести нижний ряд на верхний:

                       __    __   __             __  ___
\        /  |  |  /|  |__   /__  |   /  \    /  |     | 
 \  /\  /   |  | / |  |--  |     |--/    \__/   |--   | 
  \/  \/    |  |/  |  |     \    |  |     \/    |     |

Это было бы так, если бы не эти противные подчеркивания.

Если мы читаем исходную строку сверху вниз и игнорируем перевод строки (получая, таким образом, R ) и заменяем каждое подчеркивание, а затем пробел пробелом с последующим подчеркиванием перед смещением строк, это результат:

                         _     _                      _ 
\        /  |  |  /|  |_    /_   |   /  \ __ /  |     | 
 \  /\  /   |  | / |  |--  |     |--/    \  /   |--   | 
  \/  \/    |  |/  |  |__   \__  |__|     \/    |__  _|_

Намного лучше! Все , что осталось сделать , это удаление первого пространства первого ряда (перемещение всех символов подчеркивания в первой строке одного символа слева), перемещение неуместны подчеркивания в Е и С на одну строку вверх и отбрасывания подчеркивание над T .

Код

li2%           e# Read an integer from STDIN and push its parity.

"A+×rµ^ÅÆÿ»£ºoU#ü T^U^ÝZe<ÄÊKÞÒ£^ÛWWø5Úí§¹T^Úêer^^°^Ã}Ã^A0R2"

281b7b         e# Convert the byte string from base 281 to base 7.
"/\n -_\\|"f=  e# Replace each digit by its corresponding character.
N/S3**         e# Turn linefeeds into three spaces.
_              e# Copy the resulting string.
"_ ":T         e# Define T.
/TW%*          e# Replace occurrences of T with T reversed.
4/z            e# Split into chunks of length 4 and zip.
W%1m>          e# Reverse and rotate the rows.
N*             e# Join the rows, separating by linefeeds.
1>             e# Discard the first character.
"\/"_W%er      e# Swap the soliduses.
"^W^]5OU"      e# Push the string that corresponds to [23 29 53 79 85].
{              e# For each character:
  i            e#   Push its code point.
   _32>        e#   Push 1 iff the code point is larger than 32.
       T=      e#   Select the element at that index from T = "_ ".
         t     e#   Replace the element at the code point's index with that char.
}/             e#
\              e# Swap the partially generated MINECARFT string on top.
4/z            e# Split into chunks of length 4 and zip.
N*             e# Join the rows, separating by linefeeds.
?              e# Select the first string iff the input was odd.
— Деннис
источник
Как это работает?
— Анатолий
@anatolyg Я отредактировал свой ответ.
— Деннис
10

Pyth - 182 байта

Использует базовый подход кодирования. Поскольку индексирование в Pyth является модульным, мне даже не нужно ничего делать для четного нечетного, просто расположить его в правильном порядке и использовать @Q. В качестве бонуса это также работает с отрицательными числами.

@mjbcs@L"_| /\\-"jCd6 56,"EWbòH\x00B)þK٣ĭIOõìæ«FFãbÐÄBØ\«¼,vã<RN>­º:w÷ò¾<éifP9e|ÉWf!FÔèà""EWbòH\x00B)þOHÿ$@ËþçX'D[¾«Â?°´=&£üá ¹»ázH×Æz3äkÕg{`!|ðY!ðGV"Q

У меня были попытки только кодировать первый, затем переключать и переключать слэши, но первая и последняя строки были слишком сложными.

Я мог бы сэкономить 6 байтов, вставив в код реальные нулевые байты, но это слишком много проблем.

Попробуйте это онлайн здесь .

Он выглядит очень плохо в Интернете, потому что выходной блок слишком мал и заворачивается. Я рекомендую возиться с dev-console и изменить его col-md-5на a col-md-7.

— Maltysen
источник
В двух строках есть куча дублированных символов, вы можете удалить 11 байтов следующим образом .
— PurkkaKoodari
8

JavaScript (ES6), 312, 285, 281, 272, 270, 263, 262260

Для предыдущих изменений смотрите историю редактирования .

Редактировать 5: В преобразовании я переключил число, связанное с -(теперь 0) и пробел (теперь 1). В полученном блоке числа 1, 2 и 3 больше не использовались. Это позволило мне использовать массив с пропущенными числами.

Редактировать 6: Улучшен литерал массива. Я попробовал это ранее, но использовал 777и 77как строки вместо чисел и заметил только сейчас, что я пропустил это.

Изменить 7: «Гольф-код» является функцией, как указано в вопросе, и нет необходимости для f=удовлетворения этой спецификации. Таким образом, удалив его, сохранив два байта.

Работает в Firefox 39:

// Testing:

f=

// Golfed code:

n=>[...`11111113ss17ss1pp11117pp3ppp
97dj3dj7822j78z213e17z3v8397gm78212
7f3kf3k1z27k7z20021200k17fppk1z001z
d7983987j2287jz2ss1lss2aabj3d7987j2aa3aza`.replace(/[123]/g,x=>[,777,'77z',77][x])].map(a=>isNaN(i=parseInt(a,36))?a:'- /\\_|'[n%2?i%6:~~(i/6)]).join``

// Testing:

;document.body.appendChild(document.createElement('pre')).innerHTML=f(0);
document.body.appendChild(document.createElement('pre')).innerHTML=f(1);
document.body.appendChild(document.createElement('pre')).innerHTML=f(2);
document.body.appendChild(document.createElement('pre')).innerHTML=f(35);
Развернуть фрагмент

Он основан на базовой системе счисления 6, и каждый символ ASCII обозначает число:

"-": 0
" ": 1
"/": 2
"\": 3
"_": 4
"|": 5

Затем я объединил числовое представление каждой строки ASCII. Например: когда первая строка ASCII содержит a /в одной позиции, а другая содержит a \в той же позиции , эта позиция становится 32базой 6 ( 20в десятичной форме). Если вы конвертируете это в базу 36 (чтобы получить один номер базы 36 на каждые два номера базы 6), вы получите k.

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

Теперь оба ответа JavaScript имеют по одному другому ответу, который имеет одинаковое количество байтов…

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

// 1. ASCII here
a=`|\\-/ _`;

// 2. ASCII here
b=`/|\\_ -`;

// Note: the ASCII strings’ backslashes have to be escaped!

[...a]
  .map((c,i)=>parseInt((c+b[i])
    .replace(/-/g,'0')
    .replace(/ /g,'1')
    .replace(/\//g,'2')
    .replace(/\\/g,'3')
    .replace(/_/g,'4')
    .replace(/\|/g,'5'),6))
  .map(c=>isNaN(c)
    ?`
`
    :c.toString(36))
  .join``
// Returns "wn3g7o", which is then put into the function as the block at the top.
— Себастьян Саймон
источник
2
Черт возьми, почему ~NaN == -1?!
— Себастьян Саймон
Я также думал о движении заднего хода ASCII - Strings построчно, чтобы избавиться от еще более завершающих пробелов (также сохраняется два байта в замене: […][x]+77, 77не нужно быть строкой больше), но дополнительная реверсивным в golfed коды не стоило того ...
— Себастьян Саймон
Я не понял этого, когда впервые прочитал год назад, но теперь я вижу технику. Объединить каждую пару символов в одну очень умно :-) Я думаю, что вы можете заменить isNaNс 1+, и ~~(i/6)с i/6|0.
— ETHproductions
Ха-ха, теперь я впереди байта;)
— ETHproductions
@ETHproductions Хорошо, подожди секунду ... Я только что заметил, что у тебя нет f=в начале, но у меня есть. Я также прочитал, что его можно удалить, поэтому я сделаю это сам, и теперь у меня есть 260 байтов. ;)
— Себастьян Симон
6

CJam, 136 байтов

"^ASÓ8¥È÷^K¯¾/^HÕ2^ÄË1jÒÝ^D^Á0îl;)HR§û|^Ê^Þ^ÇÝÅ^ßNlz^TfÑ^Øj>À^à 4#bH\¿^Äî·íì^E^A~(¿ø³(ú´,^È(¡j>è?#'»vçPïju87)×"
265b8b[S9*'|3*+S2*]"/-_\| "+f=s4/56/ri=zN*

Выше используется символ каретки, так как код содержит непечатаемые символы.

Перевод строки предназначен исключительно для «читабельности». Попробуйте онлайн в интерпретаторе CJam .

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

Пример запуска

$ LANG=en_US
$ xxd -ps -r > minecraft.cjam <<< 220153d338a5c8f70bafbe2f08d53284cb316ad2dd048130ee6c3b294852a7fb7c8a9e87ddc59f4e6c7a1466d1986a3ec08320342362485cbf84eeb7edec05017e28bff8b328fab42c8828a16a3ee83f2327bb76e750ef6a75383729d7223236356238625b53392a277c332a2b53322a5d222f2d5f5c7c20222b663d73342f35362f72693d7a4e2a
$ cjam minecraft.cjam <<< 2; echo
                       __    __   __             __  ___
  /\  /\    |  |\  |  |     /    |  |     /\    |     | 
 /  \/  \   |  | \ |  |--  |     |--\    /__\   |--   | 
/        \  |  |  \|  |__   \__  |   \  /    \  |     | 
$ cjam minecraft.cjam <<< 1; echo
                       __    __                        
\        /  |  |  /|  |     /    |   /  \ __ /  |     | 
 \  /\  /   |  | / |  |--  |     |--/    \  /   |--   | 
  \/  \/    |  |/  |  |__   \__  |__|     \/    |__  _|_

идея

Этот подход имеет некоторые сходства с тем, что был в моем другом ответе , но он намного проще и (что неутешительно) немного короче.

Мы ищем способ кодировать следующую строку:

                       __    __   __             __  ___                       __    __                         
  /\  /\    |  |\  |  |     /    |  |     /\    |     | \        /  |  |  /|  |     /    |   /  \ __ /  |     | 
 /  \/  \   |  | \ |  |--  |     |--\    /__\   |--   |  \  /\  /   |  | / |  |--  |     |--/    \  /   |--   | 
/        \  |  |  \|  |__   \__  |   \  /    \  |     |   \/  \/    |  |/  |  |__   \__  |__|     \/    |__  _|_

После заполнения каждой строки (для достижения постоянной длины строки), архивирования (транспонирования строк и столбцов) и удаления перевода строки, эта строка должна быть закодирована:

   /  /  /   \    \   /  /   \    \    \         |||         ||| \    \    \ |||         |||_ -__ -_          |  / \_  __  _         |||_ - _ -  |\    \           /  /  /_  \_   \    \         |||_ - _ -         _   _|||_    \    \    \   /  /   \    \   /  /  /           |||         |||   /  /  /   |||         |||_ -__ -_          |  / \_  __  _         |||  -_  -_  /| /           \    \  _ \ _ /  /  /           |||  -_  -_           _ |||   _

Мы заменим каждую подстроку " |||"на 0 , каждую подстроку " "на 1 и символы "/-_\| "с 2 до 7 , образуя массив базы 8 цифр, которые могут быть закодированы в виде строки байтов.

Декодирование работает путем изменения шагов сверху.

Код

"^ASÓ8¥È÷^K¯¾/^HÕ2^ÄË1jÒÝ^D^Á0îl;)HR§û|^Ê^Þ^ÇÝÅ^ßNlz^TfÑ^Øj>À^à 4#bH\¿^Äî·íì^E^A~(¿ø³(ú´,^È(¡j>è?#'»vçPïju87)×"

265b8b        e# Convert from base 265 to base 8.
[S9*'|3*+S2*] e# Push ["         |||" "  "].
"/-_\| "+     e# Concatenate to push ["         |||" "  " '/' '-' '_' '\' '|' ' '].
f=            e# Select the elements that correspond to the base 8 digits.
s4/           e# Flatten and chop into chunks of length 4 (columns).
56/           e# Chop into two subarrays of 56 columns.
ri            e# Read an integer from STDIN.
=             e# Select the corresponding subarray.
              e# Arrays wrap around, so [A B]0= eq. [A B]2= and [A B]1= eq. [A B]3=.
zN*           e# Zip and join the rows, separating by linefeeds.
— Деннис
источник
— FryAmTheEggman
4

Ракетка, 443 434 386 байт

(require file/gunzip net/base64)(define(f n)(define o(open-output-bytes))(gunzip-through-ports(open-input-bytes(base64-decode #"H4sIAK8Lt1UAA22Q3Q3AIAiE352CBcwtRHLpHg7f8lubahRUDuVD5DjItrH9REgOEWgskfVMDeca1GWcSmN2WFBtlUTdzdmSOT0BpEpGnjxUAf2RmvPq1OyKGF6N5V1nvgYcWjeod/Hj8JotBRtH0qM48OeoWrBxJH23KL/dOMh4IDXe8MUbT1AqtKkBAAA="))o)(list-ref(string-split(get-output-string o)"a")(modulo n 2)))

Просто для удовольствия.

(require file/gunzip net/base64)
(define (f n)
  (define o (open-output-bytes))
  (gunzip-through-ports
   (open-input-bytes
    (base64-decode #"H4sIAK8Lt1UAA22Q3Q3AIAiE352CBcwtRHLpHg7f8lubahRUDuVD5DjItrH9REgOEWgskfVMDeca1GWcSmN2WFBtlUTdzdmSOT0BpEpGnjxUAf2RmvPq1OyKGF6N5V1nvgYcWjeod/Hj8JotBRtH0qM48OeoWrBxJH23KL/dOMh4IDXe8MUbT1AqtKkBAAA="))
   o)
  (list-ref (string-split (get-output-string o) "a") (modulo n 2)))

Примечание: вам может понадобиться #lang racketлиния для запуска в DrRacket.

— Winny
источник
1
Точно 100 байтов.
— user253751
1
Давай! Я знаю, что вы также можете сделать это до 343
— Оптимизатор
Я не вижу, чтобы это произошло, если я не откажусь от этого подхода.
— Винни
Вам не нужно использовать базовые 64 символа. Вы можете использовать только необработанные символы Юникода, которые отправляет gunzip
— MilkyWay90
4

05AB1E , 179 177 176 байт

"
 -/\_|"•ÿ%Ò´Åçδ’Üå·Äm…½µƵδø5)ǝ®∊∊Ý®þCĀ₆áÝoþ²ši¤Æ%ßû¤%¦Ï≠θĀ5¾₃ʒŸQ>Šn°η8±8d¸6':…é’b…÷‡ö©«&‡huѦ%λÁZÊJÌ₅ú∞°»ó₄ι«ÓW´×ƒ×ùqiò2D1āwθóÆ˲’
Tι#и∊²ý‚KʒFæΩZºÿÏ";ηiʒæøвøïž‚è°ć½∊•7вèJ2äIè

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

Объяснение:

•ÿ%Ò´Åçδ’Üå·Äm…½µƵδø5)ǝ®∊∊Ý®þCĀ₆áÝoþ²ši¤Æ%ßû¤%¦Ï≠θĀ5¾₃ʒŸQ>Šn°η8±8d¸6':…é’b…÷‡ö©«&‡huѦ%λÁZÊJÌ₅ú∞°»ó₄ι«ÓW´×ƒ×ùqiò2D1āwθóÆ˲’
Tι#и∊²ý‚KʒFæΩZºÿÏ";ηiʒæøвøïž‚è°ć½∊•

это сжатое число :

669530978249988431396781816197276307266403407188962925862194299697873953319419752813246251351417090709766331736351616127424760949905163941809417778114834562736028512279028673309866195447599979612590918985644583407413903825059942009898007791080822453262749380245316127735585410697701790387188175543639634091138422651942833048832372950797322005040161476426127678479662921265139425

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

7в преобразует его в Base-7 в виде списка, поэтому мы получаем список цифр:

[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,5,5,1,1,1,1,5,5,1,1,1,5,5,1,1,1,1,1,1,1,1,1,1,1,1,1,5,5,1,1,5,5,5,0,1,1,3,4,1,1,3,4,1,1,1,1,6,1,1,6,4,1,1,6,1,1,6,1,1,1,1,1,3,1,1,1,1,6,1,1,6,1,1,1,1,1,3,4,1,1,1,1,6,1,1,1,1,1,6,0,1,3,1,1,4,3,1,1,4,1,1,1,6,1,1,6,1,4,1,6,1,1,6,2,2,1,1,6,1,1,1,1,1,6,2,2,4,1,1,1,1,3,5,5,4,1,1,1,6,2,2,1,1,1,6,0,3,1,1,1,1,1,1,1,1,4,1,1,6,1,1,6,1,1,4,6,1,1,6,5,5,1,1,1,4,5,5,1,1,6,1,1,1,4,1,1,3,1,1,1,1,4,1,1,6,1,1,1,1,1,6,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,5,5,1,1,1,1,5,5,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,4,1,1,1,1,1,1,1,1,3,1,1,6,1,1,6,1,1,3,6,1,1,6,1,1,1,1,1,3,1,1,1,1,6,1,1,1,3,1,1,4,1,5,5,1,3,1,1,6,1,1,1,1,1,6,0,1,4,1,1,3,4,1,1,3,1,1,1,6,1,1,6,1,3,1,6,1,1,6,2,2,1,1,6,1,1,1,1,1,6,2,2,3,1,1,1,1,4,1,1,3,1,1,1,6,2,2,1,1,1,6,0,1,1,4,3,1,1,4,3,1,1,1,1,6,1,1,6,3,1,1,6,1,1,6,5,5,1,1,1,4,5,5,1,1,6,5,5,6,1,1,1,1,1,4,3,1,1,1,1,6,5,5,1,1,5,6,5]

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

èиндексирует каждую цифру в строке "\n-/\_|", а Jзатем объединяет весь список вместе, что дает нам следующее:

                       __    __   __             __  ___
  /\  /\    |  |\  |  |     /    |  |     /\    |     |
 /  \/  \   |  | \ |  |--  |     |--\    /__\   |--   |
/        \  |  |  \|  |__   \__  |   \  /    \  |     |                       __    __                        
\        /  |  |  /|  |     /    |   /  \ __ /  |     |
 \  /\  /   |  | / |  |--  |     |--/    \  /   |--   |
  \/  \/    |  |/  |  |__   \__  |__|     \/    |__  _|_

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

2äразбивает строку на две части.
Ièвзять входные данные и проиндексировать их (с автоматическим переносом), чтобы получить одну из двух частей, которая затем выводится неявно.

Огромное спасибо ASCII-компрессору @MagicOctopusUrn, который использовался для генерации сжатого числа и транслитерации Base-7. Попробуйте онлайн. (После этого транслитерация была введена в игру путем изменения строки и числа в стеке, используя ввместо того, Bчтобы составить список цифр, и индексировать в строку с помощью è.

— Кевин Круйссен
источник
3

C 251 байт

k(w){char*f="_-/\\|]^^^\0<&*&)&3&(&&WX&J&*&\0t_&/&3&\0`);35)I5M\0a).@7).8-;./.-\0j()(0(1+4()(*+4+4()(04+",*o=f+4,m[229]="",i=7,c=10,p;for(memset(m,32,228);i;c=*f++^(w%2&i--/2==2)*115)for(p=0;*++o;m[(w%2?4-i/6-p/57:p/57)*57+p%57]=c)p+=*o-37;printf(m);}

Это функция, kкоторая получает параметр и печатает сообщение stdout.

Более читаемая версия:

k(w)
{
    char*f="\n_-/\\|", // characters to fill in
        *o= " "// for each character, the list of positions to put it in, difference-encoded
        "]%%^^^\0"                  // for '\n' (newline)
        "<&*&)&3&(&&WX&J&*&\0"      // for '_' (underscore)
        "t_&/&3&\0"                 // for '-' (minus)
        "`);35)I5M\0"               // for '/' or '\' (slashes)
        "a).@7).8-;./.-\0"          // for '\' or '/' (slashes)
        "j()(0(1+4()(*+4+4()(04+",  // for '|' (vertical bar)
        m[229]="",  // message to generate
        i, // index of character, running 7...1
        c, // current character to fill in
        p, // where to place the character
        y; // y-coordinate of the character

    memset(m,32,228); // fill the message with spaces
    for(i=7;--i;)
    {
        c=*f++;
        c^=~w%2|i/2^1?0:115; // flip the direction of slashes, if needed
        for(p=0;*++o;)
        {
            p+=*o-37; // jump to next position
            y=p/57; // extract the y-coordinate
            y=w%2?4-i/5-y:y; // flip the y-coordinate, if needed
            m[y*57+p%57]=c; // place the character
        }
    }
    printf(m); // print the message
}

Сначала готовится пустое сообщение (заполненное пробелами). Для каждого символа (например, |или -) у него есть список позиций для размещения этого символа.

Для каждой позиции, если должна быть напечатана перевернутая версия, позиция переворачивается. То есть его вертикальная координата yзаменяется на 4-yили 3-y(в зависимости от того, является ли символ подчеркиванием). Кроме того , направления слеш перевернуты - это осуществится XORс 115.

Эта управляющая структура также используется для размещения символов новой строки - кажется, более эффективно добавить еще 4 координаты в список, чем писать явный цикл.

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

___ 
 |    |
 |    |
 |   _|_

Для правильного вывода код должен размещать |символы после _символов.

Кроме того, чтобы строка управления содержала только символы ASCII, я ее кодировал:

  • Он записывает различия между позициями вместо самих позиций - это уменьшает диапазон
  • Числа в строке 37добавлены к ним, чтобы сдвинуть их в диапазон ASCII 32 ... 127. Я мог бы добавить меньшее число, но 37избегал таких символов, как "и \, которые должны быть экранированы внутри строковых литералов.
  • Два числа были больше 127 - например, первый -символ появляется в позиции 137. Чтобы учесть это, я добавил искусственный -символ в другой позиции (79), который позже перезаписывается - символ |также появляется в позиции 79.

Еще одна забавная вещь заключалась в том, что я не мог использовать putsдля вывода строки - это привело бы к дополнительному завершающему переводу строки. Так что я использовал printfвместо этого.

Кроме того, число 57появляется в коде гольфа 4 раза - казалось бы, многословное выражение (w%2?4-i/6-p/57:p/57)*57+p%57позволяет исключить переменную y, делая код короче.

— anatolyg
источник
С, кажется, такой язык "всегда пиши эту конструкцию с этим кодом" ... Это ... очень ... хм ... +1;)
— хлоп
3

Perl, 292 259 246 байт

$_="Svv __SS__S nnSv nnSnnn
i kjSkj hw|j h|wS /SwrhSi pq hwS |
 mSlmSlS |S| l |S|--wS |--lSSmnnlS |--S |
k ihSih jw|h j|S|__S g__S|oosjSk ih jS|ooSo|o";s/v/SSSSS/g;s/w/S|S/g;s/S/  /g;<>&1?y"g-s"\\/\\  /\\ ___ |":y"g-s"\\  \\/\\/_ /\\| ";print $_

Он использует тот факт, что две строки в основном похожи (например, весь IE и C) и делает строку из символов, которые отображаются по-разному, в зависимости от того, какая версия отображается. например, m означает «прямая косая черта для строки, идущей вправо, обратная косая черта в перевернутой». Это делает замену транслитерации для отображения правильного символа. Пробелы также кодируются по длине прогона с использованием подстановок строк.

многострочный:

$_="Svv __SS__S nnSv nnSnnn
i kjSkj hS|S|j h|S|SS /SS|SrhSi pq hS|SS |
 mSlmSlS |S| l |S|--S|SS |--lSSmnnlS |--S |
k ihSih jS|S|h j|S|__S g__S|oosjSk ih jS|ooSo|o";
s/v/SSSSS/g;
s/w/S|S/g;
s/S/  /g;
<>&1?
    y"g-s"\\/\\  /\\ ___ |"
:
    y"g-s"\\  \\/\\/_ /\\| ";
print $_

Идея:

Поскольку в выходных данных имеется только 22 уникальных столбца, его можно сохранить как 22 * ​​4 = 88 символов с диапазоном 0-17 (все возможные символы "двойного значения") вместе с поиском в 56 символов. таблица с одной записью в диапазоне 0-21 на столбец. Теоретически это может быть закодировано с <100 байтами, однако трудно сделать это чистым выигрышем из-за более сложного кода для его декодирования.

— samgak
источник
2
Вы можете побрить пару байтов - y / foo / bar / является синонимом tr / foo / bar /
— ryanm
2

CJAM, 206

Два изображения ascii имеют кодировку base-216, один байт = 3 символа.

" _\/|-":A;S7*"!D!D"+:B;qi2%{B"h  °°¤8 2 °2,J° °"",4# °³8=Ô° Ó\"# Ó °""\"z °Â89D-D·° z ·!¶"}{B"'    '!J"+"#h °¼88 2 °°  ° °""2/\" °²8=Ô° Óh#L Ó °""  h°°9D-D°,2 h° °"}?]{{i32-__36/A=@6/6%A=@6%A=}/N}/

Проверьте это здесь

— Arnaud
источник
2

Powershell, 275 253 248 байт

param($n)$d='8 \83484/7/484302 92984308 92918--118--128||6//0\16116129558| \/ |8 /02083\6/10018/6\302 955776_71 9_7_'
'8\,__,777,/6 /,\6/6\,_8 -- _,88,888,  ,||||||'-split','|%{$d=$d-replace+$i++,$_}
0..3|%{$l=$_;-join$d[(0..55|%{$_*8+$l*2+$n%2})]}

Тестовый скрипт:

$f = {

param($n)$d='8 \83484/7/484302 92984308 92918--118--128||6//0\16116129558| \/ |8 /02083\6/10018/6\302 955776_71 9_7_'
'8\,__,777,/6 /,\6/6\,_8 -- _,88,888,  ,||||||'-split','|%{$d=$d-replace+$i++,$_}
0..3|%{$l=$_;-join$d[(0..55|%{$_*8+$l*2+$n%2})]}

}

&$f 2
&$f 1

Выход:

                       __    __   __             __  ___
  /\  /\    |  |\  |  |     /    |  |     /\    |     |
 /  \/  \   |  | \ |  |--  |     |--\    /__\   |--   |
/        \  |  |  \|  |__   \__  |   \  /    \  |     |
                       __    __
\        /  |  |  /|  |     /    |   /  \ __ /  |     |
 \  /\  /   |  | / |  |--  |     |--/    \  /   |--   |
  \/  \/    |  |/  |  |__   \__  |__|     \/    |__  _|_

Основные идеи

Метод сжатия является расширенным методом CJam Дениса ♦:

  1. Создайте строку перед сжатием:
    • символы первого столбца обоих ASCII искусств, затем
    • символы второго столбца, затем
    • символы третьего столбца и так далее ...
  2. Сжать, используя 10 последовательных замен (10, потому что Powershell может использовать числа 0..9 в качестве строк, это делает алгоритм распаковки короче. Замены, найденные методом грубой силы.)

Скрипт для сжатия:

$src =
"                       __    __   __             __  ___", # line1, art1
"                       __    __                         ", # line1, art2
"  /\  /\    |  |\  |  |     /    |  |     /\    |     | ", # line2, art1
"\        /  |  |  /|  |     /    |   /  \ __ /  |     | ", # line2, art2
" /  \/  \   |  | \ |  |--  |     |--\    /__\   |--   | ", # line3, art1
" \  /\  /   |  | / |  |--  |     |--/    \  /   |--   | ", # line3, art2
"/        \  |  |  \|  |__   \__  |   \  /    \  |     | ", # line4, art1
"  \/  \/    |  |/  |  |__   \__  |__|     \/    |__  _|_"  # line4, art2

$z=-join(0..$src[0].Length|%{
    $p=$_
    $src|%{$_[$p]}
})
$z

Строка сжатия перед:

   \  /     /\    /    \  \    /    \/      /\    /    \  \    /    \/     /  \                   ||||||                  ||||||  \    /    \/     /  \   ||||||          ||||||__  --____  --__                    ||    //  \\__    ____    __                  ||||||_   -- __   -- _  | \/ |   /  \                    \  /     /\  /__  \  \__  /    \/     /  \                   ||||||_   -- __   -- _                _      __ ||||||_      _
— Mazzy
источник
Объяснение в вашем ответе, вероятно, было приложено больше усилий, чем все мои ответы вместе взятые! +1
— MilkyWay90
1

SAS, 442 байта

%macro a(b);&b=tranwrd(&b,put(i,1.),repeat('A0'x,i));%mend;%macro b(z);length a b c d$99;if mod(&z,2)then do;a='992__3__';b='\7/1|1|1/|1|4/3|2/1\0__0/1|4|';c='0\1/\1/2|1|0/0|1|--1|4|--/3\1/2|--2|';d='1\/1\/3|1|/1|1|__2\__1|__|4\/3|__1_|_';end;else do;a='992__3__2__65__1___';b='1/\1/\3|1|\1|1|4/3|1|4/\3|4|';c='0/1\/1\2|1|0\0|1|--1|4|--\3/__\2|--2|';d='/7\1|1|1\|1|__2\__1|2\1/3\1|4|';end;do i=0to 9;%a(a)%a(b)%a(c)%a(d)end;put a/b/c/d;%mend;`

Non-golfed:

%macro a(b);
  &b=tranwrd(&b,put(i,1.),repeat('A0'x,i));
%mend;

%macro b(z);
length a b c d$99;
if mod(&z,2)then do;
  a='992__3__';
  b='\7/1|1|1/|1|4/3|2/1\0__0/1|4|';
  c='0\1/\1/2|1|0/0|1|--1|4|--/3\1/2|--2|';
  d='1\/1\/3|1|/1|1|__2\__1|__|4\/3|__1_|_';
end;
else do;
  a='992__3__2__65__1___';
  b='1/\1/\3|1|\1|1|4/3|1|4/\3|4|';
  c='0/1\/1\2|1|0\0|1|--1|4|--\3/__\2|--2|';
  d='/7\1|1|1\|1|__2\__1|2\1/3\1|4|';
end;
do i=0to 9;
  %a(a)
  %a(b)
  %a(c)
  %a(d)
end;
put a/b/c/d;
%mend;

тесты:

data a;
  %b(1)
  %b(2)
  %b(0)
  %b(35)
run;
                       __    __
\        /  |  |  /|  |     /    |   /  \ __ /  |     |
 \  /\  /   |  | / |  |--  |     |--/    \  /   |--   |
  \/  \/    |  |/  |  |__   \__  |__|     \/    |__  _|_
                       __    __   __             __  ___
  /\  /\    |  |\  |  |     /    |  |     /\    |     |
 /  \/  \   |  | \ |  |--  |     |--\    /__\   |--   |
/        \  |  |  \|  |__   \__  |   \  /    \  |     |
                       __    __   __             __  ___
  /\  /\    |  |\  |  |     /    |  |     /\    |     |
 /  \/  \   |  | \ |  |--  |     |--\    /__\   |--   |
/        \  |  |  \|  |__   \__  |   \  /    \  |     |
                       __    __
\        /  |  |  /|  |     /    |   /  \ __ /  |     |
 \  /\  /   |  | / |  |--  |     |--/    \  /   |--   |
  \/  \/    |  |/  |  |__   \__  |__|     \/    |__  _|_

Возможно, можно сэкономить немного кода, поместив их во входные блоки, но это добавляет ограничение, что макрос может быть только один раз для шага данных, который, я чувствую, нарушает дух написания его как макроса. (И я подозреваю, что добавление подсказки для получения ввода в шаге данных добавляет больше символов).

— Джо
источник
1

Баш, 247 байт

(($1%2)) && c=tail || c=head
base64 -d <<<H4sIAF/3uFUCA31Q2w3AIAj8ZwoWMLcQyS3i8JWXtWlTI6BwPA7Vz0Nunc9HhKSowlJU57qWJjBoZ/4a41o8aC4NsTBjbMgYkQDStCIrDz3AbmRuYjpzPTOGG5P9/gmKtQddFy8eMbOn4Khb7NE88ObRs+DgUez3iqrtwYPMAoWJhU/KBeJFPOCqAQAA | zcat | $c -n4

Строки сцеплены и сжаты.

— g.rocket
источник
1

PHP, 225 байт

Уродливое, грубое решение.

echo str_split(gzinflate(base64_decode('dZDdDcAgCITfnYIFzC1Ecos4fOW3Nm2NgsohfIp8DrJtbB8RkkMEGktk7anhXIO6jFNpzA4Lqq2SqLs5WzKnJ4BUycjOQzXQhdScd6dmV8Rwa7rqP9/QukE9ixeGt2wpODASHoWBN0a1ggMj4fuHsuyBQcYDqfH/XrwA')),224)[$argv[1]%2];

Я сжал, затем base64 закодировал сцепленные строки для отображения. Код декодирует, распаковывает и разбивает его на части по 224 символа. Первая строка состоит из 224 символов без завершающей строки, вторая - из 201 символа (также после нее нет новой строки). Четность аргумента командной строки ( $argv[1]%2) используется в качестве индекса в массиве, сгенерированном str_split().

— axiac
источник
1

Haskell, 138 байт

m x=do
 h<-readFile"a"
 return$take 225.drop(225*mod x 2)<$>find((==h).hash.pack)(replicateM 425"/\\|_- ")

Это немного взломать. Я перебираю хэш SHA256 для объединения двух текстов майнкрафта, а затем разделяю их и выбираю соответствующий текст на основе параметра x. Это, конечно, очень непрактично и не может быть вычислено в режиме реального времени, и на этом пути могут быть даже столкновения, насколько я знаю.

Поскольку Haskell не может иметь ASCII-представление этого хэша в строке, я читаю его из файла с именем «a» и поэтому добавил к моему счету 32 байта.

  • readFile и пакет из Data.ByteString.Char8
  • хеш от Crypto.Hash.SHA256

Explaination:

replicateM 425"/\\|_- "

Создает список каждой комбинации букв "/ \ | _-" на 425 букв (длина обоих текстов Minecraft вместе взятых)

find((==h).hash.pack)

Выберите первый, который соответствует хешу

take 225.drop(225*mod x 2)

Первый текст состоит из 225 букв, другой - ровно 200.

— судейская шапочка
источник
106 байтов, а не 138
— кошка
См. Мое объяснение, я добавил 32 байта, потому что я читаю файл длиной 32 байта
— BlackCap
1

Javascript (ES6), 403 296 байт

(Перенесено из моего предыдущего ответа ) Опробуем новый метод:

n=>`55555559Å9Å${n%2?`55555558556776}}5Y75Y¥Æ75786¡YAA[7ćA5Fï5¡YFéA8Y§5}\x83AEÅKÅ\x99}5§5\x999\x95`:`Q5555Q9Ý>6¡77¡}}5Y7756¡75768Y¡AA£7ćA5Fû5u¡FéAY55¡}}­EÅKÅ}G;5¡}5}`}`.replace(r=/./g,x=>(163+x.charCodeAt()).toString(6).slice(1)).replace(r,x=>' /|\\_-'[x]).match(/.{56}/g).join`
`

Обратите внимание, что есть несколько непечатаемых символов; они были заменены, например, на \x83.

Само кодирование примерно на 40 байт короче, чем другое, но процесс декодирования более сложный. Я использовал систему base-216, которую другие использовали для кодирования текста. Для справки вот код, который я использовал:

// normal MINECRAFT
a='00000000000000000000000440000440004400000000000004400444'+
  '00130013000020023002002000001000020020000013000020000020'+
  '01003100300020020302002550020000025530000144300025500020'+
  '100000000300200200320024400034400200030010000300200000200';

// upside-down MINECRAFT
// un-comment this one to run it
/*
a='00000000000000000000000440000440000000000000000000000000'+
  '30000000010020020012002000001000020001003044010020000020'+
  '03001300100020020102002550020000025510000300100025500020'+
  '003100310000200210020024400034400244200000310000244004240';
*/

console.log(a.replace(/.../g,x=>String.fromCharCode(parseInt(b[i],6)+53)));

Это в основном берет текст ASCII (предварительно преобразованный в базу 6) и утраивает его сам, изменяя его на базу 216. Затем добавляется 53 для удаления большинства непечатных символов.

Предложения приветствуются!

Вот оригинальный 403-байтовый код:

a=n=>{y=[' ','/','|','\\','_','-'],x=`55555559Å9Å${n%2?`55555555¡55Y}}eA5;5};GÝY}5}¡k;77;} 757Ĉ5G;7ć75§H5AB77Ý8ÝEÑ5H5EÅÕ`:`Q5555Q9Ý6¡k5}\u008FAA5;5}}5k5}5}Y§G77G} 757Ċ5?×7ć7;55GAAI7Ý8ÝA865GA5A`}`;b=x.split('').map(x=>x.charCodeAt(0)-53);for(c=[],i=b.length;i--;){c[i]=b[i].toString(6);while(c[i].length<3)c[i]='0'+c[i]}d=c.join('').replace(/\d/g,x=>y[x]).split('');d[56]=d[112]=d[168]=`
`;return d.join('')};

Использование forцикла, whileцикла, четырех переменных, которые использовались только один раз, и тонна длинных алгоритмов для простых вещей. Мальчик, я улучшился ...

— ETHproductions
источник
Вы, вероятно, можете полностью удалить y=[' ','/','|','\\','_','-'],и вместо y[x]записи ' /|\\_-'[x]. =)
— Себастьян Симон
@Xufox Я сделал это и многое другое, играя в гольф 107 байтов!
— ETHproductions
0

Python, 312 байт

def y(b):
 x=int(['4vwhclv10tuk4z18gf73aimn6zvwkrhxekphfn1lxocj9ezchd1cd1cv97p3f6k12s8hcjznnm5iq3om4vgxvugp3makgu4n3f6qxvdrtl4c0lva12hwt','8uzwdylhtrf6oqnwnck8pfxu25m5844tuo2700v3zoeuvossx1b47rnwyrmqodau3feu3spi9jydhyxvntv48vojx9iq9af78wufzn1'][b%2],36);x<<=69;s="";t=" /\\-|_\n"
 while x:s+=t[x&7];x>>=3
 print s

Функция печатает вывод данных с использованием int

— синий
источник
Да, я просто смотрю на аккуратный способ сжать его еще дальше, хотя
— Blue
Как это работает?
— Оливер Ни
Это база-36? но если это что-то
— Оливер Ni
По сути, он сохраняет два результата в списке, а затем получает правильный результат, используя функцию модуля. Затем он декодирует его с базы 36, как вы и думали. Поскольку это была большая степень 2, я удалил некоторые символы, выполнив >> 69. Затем я использую базовую функцию перевода, чтобы превратить ее в правильный вывод.
— Синий,
0

C, 321 байт

Закодировал повторение и индекс символа в строку.

main(n,v,p,c)char**v,*p,*c;{c=" _/\\|-\n";for(p=atoi(v[1])%2?"8@8iXivs8rhththrthtPrXt`rhspiprhtPtvpshrshr`thtprpthtmhtPtmrXshr`tm`tvhsrhsrXthtrhthti`sihtitPsrXtihqtq":"8@8iXi`i8PihavhrshrsXthtshthtPrXthtPrsXtPtvprhsrhs`thtpspthtmhtPtmsXris`tm`tvr8shththsthti`siht`shrXshtPtw";*p;p++)for(n=*p/8^15;n--;)putchar(c[*p&7]);}
— Коул Камерон
источник
0

Питон 3, 486 533 612

r=str.replace;m,p=r(r(r('''YYYYY   __YA AYY   A___
  /\  /\YX\  X Y/YX Y/\Y| Y|
 /  \/  \   X \ X--  | Y|--\Y/__\   |--   |
/YY\  X  \XA \A|   \  /Y\  | Y| ''','X','|  |'),'Y','    '),'A','__  '),print;
if int(input())%2==0:p(m)
else:
 q,i,u=m.split('\n')[::-1],0,[[23,24,29,30],[42,43],[],[23,24,29,30,34,35,53,49,50,55]];q.insert(0,q.pop())
 while i<len(q):
  x=list(r(q[i],'_',' '))+[' ']
  for a in u[i]:x[a]='_'
  p(r(r(r(r(''.join(x),'___',''),"\\",'t'),'/',"\\"),'t','/'))
  i+=1
— Оливер Ни
источник
0

PHP , 263 байта

<?=strtr('3333 20220'.['2 0332 020_
2/\2/\211\113/2113/\212 1
 /2\/2\ 11 \ |1412 14\22/0\ 14 1
/32 \112\|102 \012 \2/22\12 1',
'
\32 /112/|13/212 /2\ 0 /12 1
 \2/\2/ 11 / |1412 14/22\2/ 14 1
2\/2\/211/1102 \010|3\/2102_|_'][$argn&1],[__,"  |","  ","     ","--"]);

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

— Йорг Хюльсерманн
источник
Вы можете сохранить еще восемь байтов с собственной заменой для 3 пробелов.
— Тит
0

Рубин, 290 байт

$><<(gets.to_i%2<1?"xCeCdCnCcC_
c/Bc/Be|ABAAf/e|Af/Be|f|
b/cB/cBd|AbBb|A--Af|--Be/CBd|--d|
/iBAAcB|ACdBCAdBc/eBAf|":"xCeC
Bi/AAc/|Af/e|d/cBbCb/Af|
bBc/Bc/d|Ab/b|A--Af|--/eBc/d|--d|
cB/cB/e|A/AACdBCAC|fB/e|Cc_|_").gsub(?C,'__').tr(?B,?\\).gsub(?A,'c|').gsub(/[a-z]/){|e|' '*(e.ord-97)}

Вероятно, слабая и поддающаяся изменению запись. По сути, это очень простое (созданное вручную) сжатие, где строчные буквы означают, что многие пробелы (на самом деле ord (ch) - пробелы «A») и прописные буквы - это лишь некоторые общие термины, которые сохранили несколько байтов.

— Петр Ленкефи
источник
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.