Đây là Calvin . Chỉ cần cố gắng để có được 20 đại diện để người dùng này có thể trò chuyện trong phòng chat PPCG Minecraft Server .

Viết chương trình hoặc hàm lấy số nguyên dương.

Nếu số nguyên là chẵn (2, 4, 6, ...), hãy in hoặc trả về chuỗi nghệ thuật ASCII chính xác này:

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

Nếu số nguyên là số lẻ (1, 3, 5, ...), hãy in hoặc trả về chuỗi nghệ thuật ASCII chính xác này:

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

Bạn có thể giả sử đầu vào luôn là một số nguyên dương.

Trong cả hai trường hợp đầu ra, có thể tùy ý có bất kỳ số khoảng trắng ở cuối bên phải của chữ "T" trên mỗi dòng và / hoặc một dòng mới duy nhất. Lưu ý làm thế nào có hai cột không gian giữa mỗi chữ cái.

Mã ngắn nhất tính bằng byte thắng.

JavaScript (ES6), 343 336 289 267 265 260 byte

Chỉ để cho vui thôi ... :) (Cảm ơn Xufox vì đã cắt 46 byte và khuyến khích tôi tự mình cắt bỏ 37 cái khác.)

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):'\\':'|  |')

Được gọi là a(4)hoặc tương tự. Hãy thử nó ở đây:

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>

Tôi đã cô đọng khoảng trắng thành các chuỗi chữ số từ 2đến 8(ví dụ 887= 23 khoảng trắng). Mỗi chữ số sau đó được thay thế bằng số khoảng trắng tương ứng. 0đại diện | |, và 1đại diện __. Nói chung, chương trình này ngắn hơn 170 byte so với hai chuỗi kết hợp (203 + 227 = 430), vì vậy tôi rất vui. :)

Chỉnh sửa: Bằng cách nào đó, nó có cùng độ dài với mục khác duy nhất tại thời điểm này .... o_o

Chỉnh sửa 2: lưu một số không gian bằng cách thay đổi n%2<1?để n%2?và trao đổi các chuỗi. Cũng đã lợi dụng thực tế là sự bắt đầu của hai chuỗi giống nhau để giảm thêm 5 byte.

Chỉnh sửa 3: |2| dường như hiển thị rất nhiều, vì vậy đơn giản hóa mỗi lần xuất hiện x, tiết kiệm 7 byte. Đề xuất của Xufox đã cắt thêm 40 byte.

Chỉnh sửa 4: Đề xuất của Xufox để thay thế \nbằng các ngắt dòng thực tế đã được thanh toán, loại bỏ 6 byte khỏi tổng số. Thay đổi xđể 0và __để 1(insert ác cười ở đây), sau đó kết hợp tất cả các (chèn số nhiều của Regex đây), như ông đã làm trong entry của mình, lưu thêm 16 byte.

Chỉnh sửa 5: Vì tôi đã chọn sử dụng các tiêu chuẩn ES6, tôi đã sử dụng phép nội suy chuỗi mẫu tùy chỉnh để tắt 2 byte cuối cùng.

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

Số đầu vào được cung cấp từ stdin.

Chạy mẫu:

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

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*?

Ở trên sử dụng ký hiệu dấu mũ, vì mã chứa các ký tự không thể in được.

Hãy thử trực tuyến trong trình thông dịch CJam .

Nếu permalink không hoạt động trong trình duyệt của bạn, bạn có thể sao chép mã từ dán này .

Chạy ví dụ

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

Ý tưởng

Thay vì mã hóa chuỗi MINECRAFT (được đệm để đạt được độ dài dòng không đổi) trực tiếp, chúng tôi sẽ mã hóa phiên bản "đã nén" của chuỗi, trong đó các hàng và cột đã được chuyển đổi.

Sau khi nén và loại bỏ các nguồn cấp, chuỗi này (hãy gọi nó là R ) phải được mã hóa:

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

Có rất nhiều khoảng trống, vì vậy chúng tôi sẽ thay thế mỗi lần xuất hiện của bộ ba không gian bằng nguồn cấp dữ liệu.

Điều này để lại cho chúng tôi bảy ký tự khác nhau ( \n -/\_|), vì vậy chúng tôi gán cho mỗi số đó một số từ 0 đến 6 và xem xét các chữ số mảng kết quả của một số 7 cơ sở, sau đó chúng tôi mã hóa thành một chuỗi byte.

Giải mã hoạt động bằng cách đảo ngược các bước từ trên.

Chuỗi nhân đôi có thể được xây dựng từ chuỗi ban đầu.

Nếu chúng ta đảo ngược thứ tự của bốn hàng và hoán đổi các khối, chúng ta có được những điều sau đây:

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

Bằng cách nào đó tương tự, nhưng rõ ràng chúng ta sẽ phải xoay các hàng để đưa hàng dưới cùng lên trên cùng:

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

Đó sẽ là nó nếu nó không dành cho những kẻ dưới da phiền phức.

Nếu chúng ta đọc chuỗi gốc từ trên xuống dưới và bỏ qua các nguồn cấp dữ liệu (do đó có được R ) và thay thế từng dấu gạch dưới theo dấu cách bằng khoảng trắng theo sau là dấu gạch dưới trước khi dịch chuyển các hàng, đây là kết quả:

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

Tốt hơn nhiều! Tất cả những gì còn lại phải làm là xóa không gian đầu tiên của dòng đầu tiên (chuyển tất cả các dấu gạch dưới trong lần đầu tiên hàng một ký tự bên trái), di chuyển các dấu gạch thất lạc trong E và C một hàng lên và vứt bỏ dấu gạch chân trên T .

Mã

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 byte

Sử dụng phương pháp mã hóa cơ sở. Vì lập chỉ mục là mô-đun trong Pyth, tôi thậm chí không phải làm bất cứ điều gì kỳ quặc, chỉ cần đặt nó theo đúng thứ tự và sử dụng @Q. Như một phần thưởng, điều này cũng hoạt động với số âm.

@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

Tôi đã cố gắng chỉ mã hóa cái đầu tiên, sau đó lật và chuyển các dấu gạch chéo, nhưng dòng đầu tiên và dòng cuối cùng quá khó.

Tôi có thể lưu 6 byte bằng cách đặt byte rỗng thực tế vào mã, nhưng điều đó quá rắc rối.

Hãy thử trực tuyến tại đây .

Nó trông thực sự xấu trực tuyến vì hộp đầu ra quá nhỏ và kết thúc tốt đẹp. Tôi khuyên bạn nên thay đổi với bảng điều khiển dev và thay đổi col-md-5thành a col-md-7.

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

Đối với các chỉnh sửa trước đó xem lịch sử chỉnh sửa .

Chỉnh sửa 5: Trong quá trình chuyển đổi, tôi đã chuyển đổi số được liên kết với -(bây giờ là 0) và khoảng trắng (bây giờ là 1). Trong khối kết quả, các số 1, 2 và 3 không được sử dụng nhiều nữa. Điều này cho phép tôi sử dụng một mảng với các số còn thiếu.

Chỉnh sửa 6: Cải thiện mảng chữ. Tôi đã thử điều này trước đây, nhưng được sử dụng 777và 77như là chuỗi thay vì số và chỉ nhận thấy rằng bây giờ tôi đã bỏ lỡ điều này.

Chỉnh sửa 7: Mã Golf Golfed là một chức năng, như được chỉ định bởi câu hỏi và không cần phải f=đáp ứng thông số kỹ thuật này. Do đó, loại bỏ nó, tiết kiệm hai byte.

Có thể chạy trong 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);

Nó dựa trên hệ thống số 6 cơ sở và mỗi ký tự ASCII là một số:

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

Sau đó, tôi đã kết hợp biểu diễn số của từng chuỗi ASCII. Ví dụ: khi chuỗi ASCII đầu tiên chứa một /vị trí và một vị trí khác chứa một vị trí\ ở cùng một vị trí , vị trí đó trở thành 32, đó là cơ sở 6 ( 20theo số thập phân). Nếu bạn chuyển đổi số này thành cơ sở 36 (để có được một số cơ sở 36 cho mỗi hai số cơ sở 6), bạn sẽ nhận được k.

Tất cả điều này đã được thực hiện trước đó và về cơ bản chức năng hoàn tác quá trình này.

Bây giờ cả hai câu trả lời JavaScript đều có một câu trả lời khác nhau, có cùng số byte byte

PS: Như một lưu ý cho bản thân tôi và một tài liệu tham khảo cho người khác, đây là mã tôi đã sử dụng:

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

"^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*

Ở trên sử dụng ký hiệu dấu mũ, vì mã chứa các ký tự không thể in được.

Nguồn cấp dữ liệu chỉ dành cho "khả năng đọc". Hãy thử trực tuyến trong trình thông dịch CJam .

Nếu permalink không hoạt động trong trình duyệt của bạn, bạn có thể sao chép mã từ dán này .

Chạy ví dụ

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

Ý tưởng

Cách tiếp cận này có một số điểm tương đồng với câu trả lời khác của tôi , nhưng nó đơn giản hơn nhiều và (khá đáng thất vọng) ngắn hơn một chút.

Chúng tôi tìm kiếm một cách để mã hóa chuỗi sau:

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

Sau khi đệm từng hàng (để đạt được độ dài dòng không đổi), nén (chuyển hàng và cột) và loại bỏ các nguồn cấp, chuỗi này phải được mã hóa:

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

Chúng tôi sẽ thay thế mỗi chuỗi con " |||"bằng 0 , mỗi chuỗi con " "bằng 1 và các nhân vật của "/-_\| "với 2 để 7 , tạo thành một mảng các cơ sở 8 chữ số, có thể được mã hóa như là một chuỗi byte.

Giải mã hoạt động bằng cách đảo ngược các bước từ trên.

Mã

"^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.

Vợt 443 434 386 byte

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

Chỉ để đá.

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

NB bạn có thể cần #lang racketdòng để chạy trong DrRacket.

05AB1E , 179 177 176 byte

"
 -/\_|"•ÿ%Ò´Åçδ’Üå·Ä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è

Hãy thử trực tuyến.

Giải trình:

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

là số nén :

669530978249988431396781816197276307266403407188962925862194299697873953319419752813246251351417090709766331736351616127424760949905163941809417778114834562736028512279028673309866195447599979612590918985644583407413903825059942009898007791080822453262749380245316127735585410697701790387188175543639634091138422651942833048832372950797322005040161476426127678479662921265139425

Hãy thử trực tuyến.

7в chuyển đổi nó thành Base-7 dưới dạng danh sách, vì vậy chúng tôi nhận được danh sách các chữ số:

[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]

Hãy thử trực tuyến.

èlập chỉ mục từng chữ số trong chuỗi "\n-/\_|", Jsau đó nối toàn bộ danh sách lại với nhau, điều này cho chúng ta biết như sau:

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

Hãy thử trực tuyến.

2ächia chuỗi thành hai phần.
Ièlấy đầu vào và lập chỉ mục cho nó (với tính năng tự động bao quanh) để có được một trong hai phần, sau đó sẽ được đầu ra hoàn toàn.

Rất cảm ơn máy nén ASCII của @MagicOctopusUrn , được sử dụng để tạo ra số nén và phiên âm Base-7. Hãy thử trực tuyến. (Sau đó, phiên âm đã được đánh gôn bằng cách đảo ngược chuỗi và số trên ngăn xếp, sử dụng вthay vì Bđể biến nó thành một danh sách các chữ số và lập chỉ mục thành chuỗi è.

C, 251 byte

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

Đây là một chức năng knhận một tham số và in thông báo tới stdout.

Một phiên bản dễ đọc hơn:

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
}

Đầu tiên, nó chuẩn bị một thông điệp trống rỗng (chứa đầy khoảng trống). Đối với mỗi nhân vật (ví dụ |hoặc -), nó có một danh sách các vị trí để đặt nhân vật đó vào.

Đối với mỗi vị trí, nếu phiên bản lộn ngược phải được in, vị trí được lật. Đó là, tọa độ dọc của nó yđược thay thế bằng 4-yhoặc 3-y(tùy thuộc vào việc ký tự có phải là dấu gạch dưới hay không). Ngoài ra, các hướng của dấu gạch chéo được lật - điều này được thực hiện bởi một XORvới 115.

Cấu trúc điều khiển này cũng được sử dụng để đặt các ký tự dòng mới - có vẻ hiệu quả hơn khi thêm 4 tọa độ vào danh sách hơn là viết một vòng lặp rõ ràng.

Có một vài trục trặc nhỏ với hệ thống này. Trước hết, chữ T cuối cùng trông hơi khác trong phiên bản lật:

___ 
 |    |
 |    |
 |   _|_

Để xuất nó chính xác, mã phải đặt các |ký tự sau_ ký tự.

Ngoài ra, để đảm bảo chuỗi điều khiển chỉ chứa các ký tự ASCII, tôi đã mã hóa nó:

• Nó ghi lại sự khác biệt giữa các vị trí thay vì chính các vị trí - điều này làm giảm phạm vi
• Các số trong chuỗi đã 37được thêm vào chúng, để chuyển chúng vào Phạm vi ASCII 32 ... 127. Tôi có thể thêm một số nhỏ hơn, nhưng 37tránh các ký tự như "và \, phải được thoát trong chuỗi ký tự.
• Hai trong số các số lớn hơn 127 - ví dụ, -ký tự đầu tiên xuất hiện ở vị trí 137. Để giải thích cho điều này, tôi đã thêm một -ký tự nhân tạo ở vị trí khác (79), sau đó được ghi đè - ký tự |cũng xuất hiện ở vị trí 79.

Một điều thú vị nữa là tôi không thể sử dụng putsđể xuất chuỗi - điều này sẽ tạo ra một dòng mới. Vì vậy, tôi đã sử dụng printfthay thế.

Ngoài ra, số 57xuất hiện 4 lần trong mã đánh gôn - biểu thức có vẻ dài dòng (w%2?4-i/6-p/57:p/57)*57+p%57khiến nó có thể loại bỏ biến y, làm cho mã ngắn hơn.

Perl, 292 259 246 byte

$_="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 $_

Nó lợi dụng thực tế là hai chuỗi hầu hết giống nhau (ví dụ như toàn bộ IE và C) và làm cho chuỗi ra khỏi các ký tự được hiển thị khác nhau tùy thuộc vào phiên bản nào đang được hiển thị. ví dụ: m có nghĩa là "một dấu gạch chéo về phía trước cho chuỗi bên phải, một dấu gạch chéo ngược trong chuỗi lộn ngược". Nó thay thế phiên âm để hiển thị đúng ký tự. Các không gian cũng được mã hóa theo chiều dài bằng cách sử dụng các chuỗi thay thế.

đa dòng:

$_="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 $_

Ý tưởng:

Vì chỉ có 22 cột duy nhất trong đầu ra, nên có thể lưu trữ dưới dạng 22 * ​​4 = 88 ký tự với phạm vi 0-17 (tất cả các ký tự "có nghĩa kép" có thể), cùng với tra cứu 56 ký tự bảng với một mục trong phạm vi 0-21 mỗi cột. Về lý thuyết, điều này có thể được mã hóa với <100 byte tuy nhiên thật khó để biến điều này thành một chiến thắng ròng vì mã phức tạp hơn để giải mã nó.

CỨU, 206

Hai hình ảnh ascii được mã hóa cơ sở-216, một byte = 3 ký tự.

" _\/|-":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}/

Kiểm tra nó ở đây

Powershell, 275 253 248 byte

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

Kịch bản thử nghiệm:

$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

Đầu ra:

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

Ý chính

Phương pháp nén là phương pháp mở rộng của CJam bởi Dennis ♦:

1. Tạo một chuỗi trước khi nén:
   • ký tự của cột đầu tiên của cả nghệ thuật ASCII, sau đó
   • ký tự của cột thứ hai, sau đó
   • ký tự của cột thứ ba và cứ thế ...
2. Nén bằng 10 lần thay thế liên tiếp (10 vì Powershell có thể sử dụng các số 0..9 làm chuỗi, điều này làm cho thuật toán giải nén ngắn hơn. Thay thế được tìm thấy bởi lực lượng vũ phu.)

Kịch bản để nén:

$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

Chuỗi nén trước là:

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

SAS, 438 byte

%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;`

Không chơi gôn:

%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;

Các xét nghiệm:

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

Có thể có thể lưu một chút mã bằng cách đặt chúng vào các khối đầu vào, nhưng điều đó thêm vào hạn chế rằng macro chỉ có thể là một lần trên mỗi kho dữ liệu mà tôi cảm thấy vi phạm tinh thần viết nó dưới dạng macro. (Và tôi nghi ngờ việc thêm một dấu nhắc để nhận đầu vào trong kho dữ liệu sẽ thêm nhiều ký tự hơn).

bash, 247 byte

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

Các chuỗi được nối và gzip.

PHP, 225 byte

Xấu, giải pháp vũ phu.

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

Tôi đã nén sau đó base64 mã hóa các chuỗi nối được hiển thị. Mã giải mã, giải nén và phân tách nó thành từng mảnh gồm 224 ký tự. Chuỗi đầu tiên là 224 ký tự không có dòng mới, chuỗi thứ hai là 201 ký tự (cũng không có dòng mới sau nó). Tính chẵn lẻ của đối số dòng lệnh ( $argv[1]%2) được sử dụng làm chỉ mục trong mảng được tạo bởi str_split().

Haskell, 138 byte

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

Đây là một chút của một hack. Tôi đang cố gắng băm nhỏ hàm băm SHA256 của phép nối hai văn bản minecraft, sau đó tách chúng ra và chọn văn bản phù hợp dựa trên tham số x. Đây là nguồn rất không thực tế và không thể được tính toán trong thời gian thực, và thậm chí có thể có những va chạm trên đường đi cho tất cả những gì tôi biết.

Vì Haskell không thể có biểu diễn ASCII của hàm băm đó trong một chuỗi, tôi đang đọc nó từ một tệp có tên "a" và đã thêm 32 byte vào điểm số của tôi.

• readFile và gói là từ Data.ByteString.Char8
• hàm băm là từ Crypto.Hash.SHA256

Giải thích:

replicateM 425"/\\|_- "

Tạo một danh sách mọi sự kết hợp của các chữ cái "/ \ | _-" trên 425 chữ cái (độ dài của cả hai văn bản minecraft kết hợp)

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

Chọn cái đầu tiên khớp với hàm băm

take 225.drop(225*mod x 2)

Văn bản đầu tiên dài 225 chữ cái, văn bản khác chính xác là 200.

Javascript (ES6), 403 296 byte

(Chuyển từ câu trả lời trước của tôi ) Thử một phương pháp mới:

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

Lưu ý rằng có một vài ký tự không thể in được; những cái này đã được thay thế bằng vd \x83.

Bản thân mã hóa ngắn hơn khoảng 40 byte so với cái kia, nhưng quá trình giải mã phức tạp hơn. Tôi đã sử dụng hệ thống cơ sở-216 mà những người khác đã sử dụng để mã hóa văn bản. Để tham khảo, đây là mã tôi đã sử dụng:

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

Điều này về cơ bản lấy văn bản ASCII (được chuyển đổi trước thành cơ sở 6) và tự nhân ba nó lên, thay đổi nó thành cơ sở 216. 53 sau đó được thêm vào để loại bỏ hầu hết các ký tự không in được.

Gợi ý chào mừng!

Đây là mã 403 byte gốc:

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('')};

Sử dụng một forvòng lặp, một whilevòng lặp, bốn biến chỉ được sử dụng một lần và một tấn thuật toán dài cho những điều đơn giản. Chàng trai, tôi đã tiến bộ ...

Python, 312 byte

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

Chức năng in đầu ra cho một int

C, 321 byte

Đã mã hóa sự lặp lại và chỉ mục ký tự thành một chuỗi.

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

Trăn 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 byte

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

Hãy thử trực tuyến!

Ruby, 290 byte

$><<(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)}

Có lẽ là một mục yếu và ngẫu hứng. Về cơ bản, việc nén (thủ công) rất đơn giản trong đó các chữ cái viết thường có nghĩa là nhiều khoảng trắng (thực tế là ord (ch) - 'A') và các chữ cái in hoa chỉ là một số thuật ngữ phổ biến lưu một vài byte.

SOGL V0.12 , 72 71 byte

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

Hãy thử nó ở đây!

SOGLs phản chiếu dọc làm việc hoàn hảo cho việc này.

Canvas , 70 byte

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

Hãy thử nó ở đây!