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

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

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

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

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

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

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

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

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

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)или похожий. Попробуйте это здесь:

a=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):'\\':'|  |')
document.getElementById("a").innerHTML = "<pre>"+a(2)+"</pre>";
document.getElementById("b").innerHTML = "<pre>"+a(3)+"</pre>";

<p id="a"></p>
<p id="b"></p>

Я сконцентрировал пробел в цепочках цифр от 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 последних байта.

Матлаб, 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
                       __    __   __             __  ___
  /\  /\    |  |\  |  |     /    |  |     /\    |     | 
 /  \/  \   |  | \ |  |--  |     |--\    /__\   |--   | 
/        \  |  |  \|  |__   \__  |   \  /    \  |     | 

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.

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.

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.

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.

Ракетка, 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.

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чтобы составить список цифр, и индексировать в строку с помощью è.

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, делая код короче.

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

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}/

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

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

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

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

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;
                       __    __
\        /  |  |  /|  |     /    |   /  \ __ /  |     |
 \  /\  /   |  | / |  |--  |     |--/    \  /   |--   |
  \/  \/    |  |/  |  |__   \__  |__|     \/    |__  _|_
                       __    __   __             __  ___
  /\  /\    |  |\  |  |     /    |  |     /\    |     |
 /  \/  \   |  | \ |  |--  |     |--\    /__\   |--   |
/        \  |  |  \|  |__   \__  |   \  /    \  |     |
                       __    __   __             __  ___
  /\  /\    |  |\  |  |     /    |  |     /\    |     |
 /  \/  \   |  | \ |  |--  |     |--\    /__\   |--   |
/        \  |  |  \|  |__   \__  |   \  /    \  |     |
                       __    __
\        /  |  |  /|  |     /    |   /  \ __ /  |     |
 \  /\  /   |  | / |  |--  |     |--/    \  /   |--   |
  \/  \/    |  |/  |  |__   \__  |__|     \/    |__  _|_

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

Баш, 247 байт

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

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

PHP, 225 байт

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

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

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

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.

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цикла, четырех переменных, которые использовались только один раз, и тонна длинных алгоритмов для простых вещей. Мальчик, я улучшился ...

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

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

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

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],[__,"  |","  ","     ","--"]);

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

Рубин, 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») и прописные буквы - это лишь некоторые общие термины, которые сохранили несколько байтов.

SOGL V0.12 , 72 71 байт

═j;ΗD^⌡⁾yō⁶⅜┐≡¼τ~≡š┘,┼◄‚4øDqψ∫‛²′Ζdκ↓±ģ░○∙ΘΝ◄ōΞ06║⁶╗i-η}┌^JY³‘''n.2%?№↕

Попробуй здесь!

Вертикальное зеркалирование SOGL отлично сработало для этого.

Холст , 70 байт

Ｃ＜aT［≤＾５ｔ‽◂6Ｚｒ!ｖ↓［ｕ0F∙ＯＦ－╫＃ｔ┬ａ*７ＺfK1!&)y＠½（＋M⇵ＰV-¼G:Ｕju╋╷(╫:N‟‾)ｎ⁸２％？↕

Попробуй это здесь!