นี่คือคาลวิน เพียงแค่พยายามที่จะได้รับ 20 ตัวแทนเพื่อให้ผู้ใช้สามารถแชทในห้องสนทนา PPCG Minecraft เซิร์ฟเวอร์

เขียนโปรแกรมหรือฟังก์ชั่นที่ใช้จำนวนเต็มบวก

หากจำนวนเต็มเป็นเลขคู่ (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>

ฉันย่อ whitespace เป็นสตริงตัวเลขจาก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 ไบต์สุดท้าย

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

หมายเลขอินพุตถูกจัดเตรียมจาก 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 (เสริมเพื่อให้ได้ความยาวบรรทัดคงที่) โดยตรงเราจะเข้ารหัสเวอร์ชัน "ซิป" ซึ่งมีการย้ายแถวและคอลัมน์

หลังจากซิปและลบ linefeeds สตริงนี้ (เรียกว่าR ) จะต้องมีการเข้ารหัส:

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

มีช่องว่างมากมายหลายช่องดังนั้นเราจะแทนที่การเกิดของ triplet ด้วยการป้อนบรรทัดแต่ละครั้ง

สิ่งนี้ทำให้เรามีอักขระที่แตกต่างกันเจ็ดตัว ( \n -/\_|) ดังนั้นเราจึงกำหนดตัวเลขแต่ละตัวจาก0ถึง6และพิจารณาตัวเลขอาเรย์หลักของตัวเลขฐาน 7 ซึ่งเราเข้ารหัสเป็นสตริงไบต์

การถอดรหัสทำงานโดยการย้อนกลับขั้นตอนจากด้านบน

สตริงที่มิร์เรอร์สามารถสร้างได้จากสตริงดั้งเดิม

หากเรากลับคำสั่งของสี่แถวและสลับ soliduses เราจะได้รับสิ่งต่อไปนี้:

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

คล้ายกัน แต่เราจะต้องหมุนแถวให้ชัดเจนเพื่อนำแถวล่างขึ้นไปด้านบน:

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

มันจะเป็นอย่างนั้นถ้ามันไม่ได้เป็นการเน้นย้ำถึงสิ่งที่น่ารำคาญเหล่านั้น

หากเราอ่านสตริงต้นฉบับจากบนลงล่างและละเว้น linefeeds (เช่นรับR ) และแทนที่ขีดล่างแต่ละอันตามด้วยช่องว่างด้วยช่องว่างตามด้วยเครื่องหมายขีดล่างก่อนจะเลื่อนแถวนี่คือผลลัพธ์:

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

ดีกว่ามาก! ทั้งหมดที่เหลือจะทำคือการลบพื้นที่แรกของแถวแรก (ขยับขีดทั้งหมดในแถวแรกตัวละครตัวหนึ่งจากซ้าย) ย้ายขีดถูกใส่ผิดในEและCหนึ่งแถวขึ้นและทิ้งขีดกว่า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 ไบต์

ใช้วิธีการเข้ารหัสพื้นฐาน ตั้งแต่การจัดทำดัชนีเป็น modular ใน 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 ไบต์ได้โดยใส่ค่า null ที่แท้จริงลงในโค้ด แต่นั่นเป็นปัญหามากเกินไป

ลองมันออนไลน์ได้ที่นี่

มันดูไม่ดีจริง ๆ ออนไลน์เพราะกล่องผลลัพธ์มีขนาดเล็กเกินไปและตัดคำ ผมขอแนะนำให้เล่นซอกับ dev คอนโซลและเปลี่ยนไปcol-md-5col-md-7

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

สำหรับการแก้ไขก่อนหน้าดูประวัติการแก้ไข

แก้ไข 5:ในการแปลงฉันสลับหมายเลขที่เกี่ยวข้องกับ-(ตอนนี้ 0) และช่องว่าง (ตอนนี้ 1) ในบล็อกผลลัพธ์ตัวเลข 1, 2 และ 3 ไม่ได้ถูกใช้อีกต่อไป สิ่งนี้ทำให้ฉันสามารถใช้อาร์เรย์ที่มีตัวเลขหายไป

แก้ไข 6:ปรับปรุงอาร์เรย์ตามตัวอักษร ฉันลองก่อนหน้านี้ แต่ใช้777และ77เป็นสตริงแทนที่จะเป็นตัวเลขและสังเกตเห็นเพียงตอนนี้ว่าฉันพลาดมันไปแล้ว

แก้ไข 7: "รหัส Golfed" เป็นฟังก์ชั่นตามที่ระบุโดยคำถามและไม่จำเป็นต้อง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 แรกมี/ที่ตำแหน่งหนึ่งและคนอื่น ๆที่มี\ในตำแหน่งเดียวกันตำแหน่งที่จะกลายเป็น32ซึ่งเป็นฐานที่ 6 ( 20ในทศนิยม) ถ้าคุณแปลงนี้ไปยังฐาน 36 (ที่จะได้รับหนึ่งในฐาน-36 จำนวนทุกสองฐานตัวเลข 6) kคุณจะได้รับ

ทั้งหมดนี้ทำไว้ล่วงหน้าและฟังก์ชั่นจะยกเลิกกระบวนการนี้โดยทั่วไป

ตอนนี้ทั้งสองคำตอบ JavaScript มีทั้งคำตอบอื่น ๆ ที่มีจำนวนไบต์เดียวกัน ...

ป.ล. : ตามหมายเหตุถึงตัวฉันและการอ้างอิงถึงคนอื่น ๆ นี่คือรหัสที่ฉันใช้:

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

ด้านบนใช้เครื่องหมายรูปหมวกเนื่องจากรหัสมีอักขระที่ไม่สามารถพิมพ์ได้

linefeed นั้นมีไว้สำหรับ "ความสามารถในการอ่าน" เท่านั้น ลองใช้ออนไลน์ในล่าม CJam

หากลิงก์ถาวรไม่ทำงานในเบราว์เซอร์ของคุณคุณสามารถคัดลอกโค้ดจากวางนี้

ตัวอย่างการวิ่ง

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

ความคิด

วิธีการนี้มีความคล้ายคลึงกับคำตอบอื่น ๆ ของฉันแต่มันก็ง่ายกว่าและสั้นกว่าเล็กน้อย

เราค้นหาวิธีการเข้ารหัสสตริงต่อไปนี้:

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

หลังจากการขยายแต่ละแถว (เพื่อให้ได้ความยาวบรรทัดคงที่) การซิป (การสลับแถวและคอลัมน์) และการลบ linefeeds สตริงนี้จะต้องมีการเข้ารหัส:

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

เราจะแทนที่แต่ละย่อย" |||"มี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)))

NB คุณอาจต้องใช้#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ซึ่งใช้เพื่อสร้างหมายเลขที่บีบอัดและตัวแปลฐาน 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);}

นี้เป็นฟังก์ชั่นที่ได้รับพารามิเตอร์และพิมพ์ข้อความไปยังkstdout

รุ่นที่อ่านได้มากขึ้น:

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(ขึ้นอยู่กับว่าตัวละครเป็นขีดล่าง) นอกจากนี้ทิศทางของการทับจะพลิก - นี้จะดำเนินการโดยมีXOR115

โครงสร้างการควบคุมนี้ยังใช้เพื่อวางอักขระบรรทัดใหม่ - ดูเหมือนว่ามีประสิทธิภาพมากกว่าในการเพิ่ม 4 พิกัดเพิ่มเติมลงในรายการมากกว่าการเขียนลูปที่ชัดเจน

มีข้อบกพร่องเล็กน้อยบางอย่างในระบบนี้ ก่อนอื่นตัวอักษรสุดท้าย T ดูแตกต่างเล็กน้อยในเวอร์ชั่นที่พลิกกลับ:

___ 
 |    |
 |    |
 |   _|_

ในการส่งออกอย่างถูกต้องรหัสจะต้องวางตัว|ละครหลัง_ตัวละคร

นอกจากนี้เพื่อให้แน่ใจว่าสายอักขระควบคุมมีเพียงอักขระ ASCII ฉันจึงเข้ารหัสมัน:

• มันบันทึกความแตกต่างระหว่างตำแหน่งแทนตำแหน่งตัวเอง - ซึ่งจะช่วยลดช่วง
• ตัวเลขในสตริงได้37เพิ่มเข้าไปแล้วเพื่อเปลี่ยนเป็น ASCII Range 32 ... 127 ฉันสามารถเพิ่มจำนวนที่น้อยลงได้ แต่37หลีกเลี่ยงตัวละครที่ชอบ"และ\ต้องหลีกหนีจากตัวอักษรสตริง
• ตัวเลขสองตัวมีค่ามากกว่า 127 ตัวอย่างเช่น-ตัวอักษรตัวแรกปรากฏที่ตำแหน่ง 137 ในการอธิบายเรื่องนี้ฉันได้เพิ่ม-ตัวละครเทียมที่ตำแหน่งอื่น (79) ซึ่งเขียนทับในภายหลัง - ตัวละคร|ก็ปรากฏที่ตำแหน่ง 79

สิ่งที่ตลกอีกอย่างหนึ่งคือฉันไม่สามารถใช้putsในการส่งออกสตริง - นี้จะสร้างขึ้นบรรทัดใหม่พิเศษ ดังนั้นฉันใช้printfแทน

นอกจากนี้ตัวเลข57จะปรากฏขึ้น 4 ครั้งในรหัส golfed - นิพจน์ที่ยืดยาว(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-แข็งแรงเล่นกอล์ฟ:

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

อาจบันทึกรหัสเล็กน้อยโดยใส่ลงในบล็อกอินพุต แต่เพิ่มข้อ จำกัด ที่แมโครสามารถหนึ่งครั้งต่อหนึ่งชุดข้อมูลเท่านั้นซึ่งฉันรู้สึกว่าละเมิดเจตนารมณ์ของการเขียนเป็นแมโคร (และฉันสงสัยว่าการเพิ่มพรอมต์เพื่อรับอินพุตใน datastep จะเพิ่มตัวอักษรมากขึ้น)

ทุบตี, 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 และ pack มาจาก 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]);}

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

ลองออนไลน์!

Ruby, 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)}

อาจเป็นรายการที่อ่อนแอและไม่น่าจะเป็นไปได้ โดยทั่วไปการบีบอัด (handcrafted) ที่ง่ายมากโดยที่ตัวอักษรตัวเล็กหมายถึงช่องว่างมากมาย (อันที่จริงแล้ว ord (ch) - ช่องว่าง 'A') และตัวพิมพ์ใหญ่เป็นเพียงคำศัพท์ทั่วไปที่บันทึกไว้สองสามไบต์

SOGL V0.12 , 72 71 ไบต์

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

ลองที่นี่!

การมิเรอร์ในแนวตั้ง SOGL ทำงานได้อย่างสมบูรณ์แบบสำหรับสิ่งนี้

Canvas , 70 ไบต์

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

ลองที่นี่!