Це Кальвін . Просто намагаюся отримати 20 представників, щоб цей користувач міг спілкуватися в чаті PPCG Minecraft Server .

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

Якщо ціле число є парним (2, 4, 6, ...), надрукуйте або поверніть цю точну графіку ASCII:

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

Якщо ціле число непарне (1, 3, 5, ...), роздрукуйте або поверніть цю точну графіку ASCII:

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

Ви можете припустити, що вхід завжди є додатним цілим числом.

В обох вихідних випадках може необов'язково бути будь-яка кількість кінцевих пробілів до правого краю "T" на кожному рядку та / або один зворотний новий рядок. Зверніть увагу, як між кожною буквою є два стовпці пробілів.

Виграє найкоротший код у байтах.

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

Вхідний номер надається з stdin.

Вибірка зразка:

>> 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 байтів, додавши фактичні нульові байти в код, але це занадто багато проблем.

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

В Інтернеті це виглядає дуже погано, оскільки вихідний блок занадто малий і загортається. Рекомендую поповнити консоль розробника та змінити col-md-5на a col-md-7.

JavaScript (ES6), 312, 285, 281, 272, 270, 263, 262, 260

Для попередніх редагувань див. Історію редагування .

Редагування 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 закодовані базовою 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;`

Не гольф:

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

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

bash, 247 байт

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

Струни з’єднуються і gziped.

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

Оскільки Haskell не може представити ASCII цього хеша в рядку, я читаю його з файлу під назвою "a" і додав до цього 32 байти до моєї оцінки.

• readFile та пакет із Data.ByteString.Char8
• хеш від Crypto.Hash.SHA256

Пояснення:

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‟‾)ｎ⁸２％？↕

Спробуйте тут!