Das ist Calvin . Ich versuche nur, 20 Wiederholungen zu erhalten, damit dieser Benutzer im PPCG Minecraft Server-Chatroom chatten kann .

Schreiben Sie ein Programm oder eine Funktion, die eine positive Ganzzahl enthält.

Wenn die Ganzzahl gerade ist (2, 4, 6, ...), geben Sie diese genaue ASCII-Zeichenfolge aus oder geben Sie sie zurück:

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

Wenn die Ganzzahl ungerade ist (1, 3, 5, ...), drucken Sie diese genaue ASCII-Zeichenfolge oder geben Sie sie zurück:

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

Sie können davon ausgehen, dass die Eingabe immer eine positive Ganzzahl ist.

In beiden Ausgabefällen kann optional eine beliebige Anzahl von nachgestellten Leerzeichen bis zum rechten Rand des "T" in jeder Zeile und / oder eine einzelne nachgestellte neue Zeile vorhanden sein. Beachten Sie, dass zwischen jedem Buchstaben zwei Spalten mit Leerzeichen stehen.

Der kürzeste Code in Bytes gewinnt.

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

Nur zum Spaß ... :) (Danke an Xufox für das Abschneiden von 46 Bytes und die Ermutigung, mir selbst 37 Bytes abzuschneiden.)

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

Genannt als a(4)oder ähnlich. Probieren Sie es hier aus:

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>

Ich habe das Leerzeichen in Ziffernfolgen von 2bis zusammengefasst 8(z. B. 887= 23 Leerzeichen). Jede Ziffer wird dann durch die entsprechende Anzahl von Leerzeichen ersetzt. 0repräsentiert | |und 1repräsentiert __. Alles in allem ist dieses Programm 170 Bytes kürzer als die beiden Strings zusammen (203 + 227 = 430), also bin ich glücklich. :)

Edit: Irgendwie ist es genau so lang wie der einzige andere Eintrag an dieser Stelle .... o_o

Edit 2: Gespeicherte etwas Platz , indem n%2<1?an n%2?und die Saiten tauschen. Nutzte auch die Tatsache, dass die Anfänge der beiden Zeichenfolgen gleich sind, um weitere 5 Bytes zu reduzieren.

Edit 3: |2| schien eine Menge zu zeigen, so dass jedes Vorkommen vereinfacht xwurde und 7 Bytes gespart wurden. Die Vorschläge von Xufox haben weitere 40 Byte abgeschnitten.

Edit 4: Der Vorschlag von Xufox, durch \ntatsächliche Zeilenumbrüche zu ersetzen , hat sich ausgezahlt und 6 Bytes von der Gesamtsumme entfernt. Durch das Ändern von xzu 0und __zu 1(böses Lachen hier einfügen) und anschließendes Kombinieren aller Elemente (Regex-Plural hier einfügen), wie er es in seinem Eintrag getan hat, wurden zusätzliche 16 Byte gespart.

Bearbeiten 5: Da ich mich für die Verwendung der ES6-Standards entschieden habe, habe ich eine benutzerdefinierte Vorlagenzeichenfolge-Interpolation verwendet, um 2 letzte Bytes zu entfernen.

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

Die eingegebene Nummer wird von stdin bereitgestellt.

Probelauf:

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

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

Oben wird die Caret-Notation verwendet, da der Code nicht druckbare Zeichen enthält.

Probieren Sie es online im CJam-Interpreter aus .

Wenn der Permalink in Ihrem Browser nicht funktioniert, können Sie den Code aus dieser Paste kopieren .

Beispiellauf

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

Idee

Anstatt den MINECRAFT-String (gepolstert, um eine konstante Zeilenlänge zu erreichen) direkt zu codieren, werden wir eine "gezippte" Version davon codieren, bei der Zeilen und Spalten transponiert wurden.

Nach dem Zippen und Entfernen der Zeilenvorschübe muss dieser String (nennen wir ihn R ) codiert werden:

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

Da es viele Läufe von Leerzeichen gibt, ersetzen wir jedes Vorkommen eines Leerzeichentripels durch einen Zeilenvorschub.

Dies lässt uns sieben verschiedene Zeichen ( \n -/\_|) übrig, daher weisen wir jedem von ihnen eine Zahl von 0 bis 6 zu und betrachten die resultierenden Array-Ziffern einer Zahl zur Basis 7, die wir dann als Byte-Zeichenfolge kodieren.

Die Dekodierung erfolgt in umgekehrter Reihenfolge.

Die gespiegelte Zeichenfolge kann aus der ursprünglichen Zeichenfolge erstellt werden.

Wenn wir die Reihenfolge der vier Zeilen umkehren und die Solidusen tauschen, erhalten wir Folgendes:

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

Irgendwie ähnlich, aber wir müssen die Reihen eindeutig drehen, um die untere Reihe nach oben zu bringen:

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

Das wäre es, wenn es nicht diese nervigen Unterstriche gäbe.

Wenn wir die ursprüngliche Zeichenfolge von oben nach unten lesen und Zeilenvorschübe ignorieren (um R zu erhalten ) und jeden Unterstrich gefolgt von einem Leerzeichen durch ein Leerzeichen gefolgt von einem Unterstrich ersetzen, bevor wir die Zeilen verschieben, ist dies das Ergebnis:

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

Viel besser! Alles, was Sie tun müssen, ist, das erste Leerzeichen der ersten Zeile zu löschen (alle Unterstriche in der ersten Zeile um ein Zeichen nach links verschieben), die falsch platzierten Unterstriche in E und C um eine Zeile nach oben zu verschieben und den Unterstrich über T zu verwerfen .

Code

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 Bytes

Verwendet den Basiscodierungsansatz. Da die Indizierung in Pyth modular aufgebaut ist, muss ich nicht einmal etwas für die gerade Ungerade tun, sondern muss es nur in die richtige Reihenfolge bringen und verwenden @Q. Als Bonus funktioniert dies auch bei negativen Zahlen.

@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

Ich hatte versucht, nur die erste zu codieren, dann die Schrägstriche umzudrehen und zu vertauschen, aber die erste und letzte Zeile waren zu hart.

Ich könnte 6 Bytes einsparen, indem ich tatsächlich null Bytes in den Code stecke, aber das ist zu viel Mühe.

Probieren Sie es hier online aus .

Es sieht online wirklich schlecht aus, weil das Ausgabefeld zu klein ist und umbrochen wird. Ich empfehle, mit der Dev-Konsole zu fummeln und die col-md-5auf a zu ändern col-md-7.

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

Informationen zu früheren Änderungen finden Sie im Bearbeitungsverlauf .

Edit 5: Bei der Konvertierung habe ich die mit -(jetzt 0) und Whitespace (jetzt 1) verknüpfte Nummer gewechselt . Im resultierenden Block wurden die Nummern 1, 2 und 3 nicht mehr so ​​oft verwendet. Dadurch konnte ich ein Array mit den fehlenden Zahlen verwenden.

Edit 6: Das Array-Literal wurde verbessert. Ich habe versucht , diese vorher, aber verwendet 777und 77als Zeichenketten anstelle von Zahlen und bemerkte erst jetzt , dass ich das verpasst hatte.

Bearbeiten 7: Der "Golfed Code" ist eine Funktion, wie in der Frage angegeben, und es besteht keine Notwendigkeit f=, diese Spezifikation zu erfüllen. So wird es entfernt und zwei Bytes gespart.

In Firefox 39 lauffähig:

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

Es basiert auf dem Zahlensystem der Basis 6 und jedes ASCII-Zeichen steht für eine Zahl:

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

Dann habe ich die Zahlendarstellung jeder ASCII-Zeichenfolge kombiniert. Beispiel: Wenn die erste ASCII-Zeichenfolge /an einer Position ein und die andere\ an derselben Position ein enthält , wird diese Position zur 32Basis 6 ( 20in Dezimalform). Wenn Sie dies in Basis 36 konvertieren (um eine Basis-36-Zahl für jeweils zwei zu erhalten) Basis-6-Zahlen zu erhalten), erhalten Sie k.

All dies wurde im Voraus durchgeführt und die Funktion macht diesen Vorgang im Wesentlichen rückgängig.

Nun haben die beiden JavaScript-Antworten jeweils eine andere Antwort, die die gleiche Byteanzahl hat ...

PS: Als Hinweis für mich und als Verweis auf andere ist dies der Code, den ich verwendet habe:

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

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

Oben wird die Caret-Notation verwendet, da der Code nicht druckbare Zeichen enthält.

Der Zeilenumbruch dient ausschließlich der "Lesbarkeit". Probieren Sie es online im CJam-Interpreter aus .

Wenn der Permalink in Ihrem Browser nicht funktioniert, können Sie den Code aus dieser Paste kopieren .

Beispiellauf

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

Idee

Dieser Ansatz hat einige Ähnlichkeiten mit dem in meiner anderen Antwort , ist jedoch viel einfacher und (ziemlich enttäuschend) etwas kürzer.

Wir suchen nach einer Möglichkeit, die folgende Zeichenfolge zu codieren:

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

Nach dem Auffüllen jeder Zeile (um eine konstante Zeilenlänge zu erreichen), dem Zippen (Vertauschen von Zeilen und Spalten) und dem Entfernen der Zeilenvorschübe muss diese Zeichenfolge codiert werden:

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

Wir werden jedes Teilzeichen ersetzen " |||"mit einem 0 , jede Teilkette " "mit einem 1 und den Zeichen des "/-_\| "mit 2 zu 7 , eine Anordnung von Basis 8 Stellen bilden, die als ein Byte - String codiert werden kann.

Die Dekodierung erfolgt in umgekehrter Reihenfolge.

Code

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

Schläger, 443 434 386 Bytes

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

Nur zum Spaß.

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

Hinweis: Möglicherweise benötigen Sie die #lang racketLeitung, um in DrRacket ausgeführt werden zu können.

05AB1E , 179 177 176 Bytes

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

Probieren Sie es online aus.

Erläuterung:

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

ist die komprimierte Zahl :

669530978249988431396781816197276307266403407188962925862194299697873953319419752813246251351417090709766331736351616127424760949905163941809417778114834562736028512279028673309866195447599979612590918985644583407413903825059942009898007791080822453262749380245316127735585410697701790387188175543639634091138422651942833048832372950797322005040161476426127678479662921265139425

Probieren Sie es online aus.

7в konvertiert es in Base-7 als Liste, so dass wir die Liste der Ziffern erhalten:

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

Probieren Sie es online aus.

èIndiziert jede Ziffer in der Zeichenfolge "\n-/\_|"und Jfügt dann die gesamte Liste zusammen. Dadurch erhalten wir Folgendes:

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

Probieren Sie es online aus.

2äTeilt die Zeichenfolge in zwei Teile.
IèNehmen Sie die Eingabe und indizieren Sie sie (mit automatischem Wrap-Around), um einen der beiden Teile zu erhalten, der dann implizit ausgegeben wird.

Ein großes Dankeschön an @MagicOctopusUrns ASCII-Kompressor , mit dem die komprimierte Zahl und das Base-7-Transliteral generiert wurden. Probieren Sie es online aus. (Nach dem der transkribieren wurde durch Umkehren der Zeichenfolge und Nummer auf dem Stapel golfed, indem вstatt Bes eine Liste von Ziffern zu machen, und der Index in den String mit è.

C 251 Bytes

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

Dies ist eine Funktion k, die einen Parameter empfängt und die Nachricht an ausgibt stdout.

Eine lesbarere Version:

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
}

Zunächst wird eine leere Nachricht vorbereitet (mit Leerzeichen gefüllt). Für jedes Zeichen (zB |oder- ) gibt es eine Liste mit Positionen, an denen dieses Zeichen platziert werden kann.

Wenn für jede Position die umgekehrte Version gedruckt werden soll, wird die Position umgekehrt. Das heißt, seine vertikale Koordinate ywird durch 4-yoder ersetzt 3-y(abhängig davon, ob das Zeichen ein Unterstrich ist). Auch die Richtungen der Schrägstriche werden gekippt - dies erfolgt durch ein XORmit115 .

Diese Kontrollstruktur wird auch zum Platzieren der Zeilenumbruchzeichen verwendet. Es scheint effizienter zu sein, der Liste 4 weitere Koordinaten hinzuzufügen, als eine explizite Schleife zu schreiben.

Es gibt ein paar kleinere Probleme mit diesem System. Zunächst sieht der letzte Buchstabe T in der gedrehten Fassung etwas anders aus:

___ 
 |    |
 |    |
 |   _|_

Um es korrekt auszugeben, muss der Code das platzieren | Zeichen nach den _Zeichen platzieren.

Um sicherzustellen, dass die Steuerzeichenfolge nur ASCII-Zeichen enthält, habe ich sie außerdem codiert:

• Es erfasst die Unterschiede zwischen den Positionen anstelle der Positionen selbst - dies verringert die Reichweite
• Die Zahlen in der Zeichenfolge wurden 37hinzugefügt, um sie in den ASCII-Bereich 32 ... 127 zu verschieben. Ich könnte eine kleinere Zahl hinzufügen, 37vermeidet aber Zeichen wie "und\ , die in String-Literalen maskiert werden müssen.
• Zwei der Zahlen waren größer als 127 - zum Beispiel erscheint das erste -Zeichen an Position 137. Um dies zu berücksichtigen, habe ich an einer -anderen Stelle (79) ein künstliches Zeichen hinzugefügt , das später überschrieben wird - das Zeichen |erscheint auch an Position 79.

Eine andere lustige Sache war, dass ich putsdie Zeichenfolge nicht ausgeben konnte - dies würde eine zusätzliche nachgestellte Newline erzeugen. Also habe ich benutztprintf stattdessen verwendet.

Außerdem kommt die Zahl 57im Golf-Code viermal vor - der scheinbar langatmige Ausdruck (w%2?4-i/6-p/57:p/57)*57+p%57ermöglicht es, die Variable zu entfernen y, wodurch der Code kürzer wird.

Perl, 292 259 246 Bytes

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

Es macht sich die Tatsache zunutze, dass die beiden Zeichenfolgen größtenteils ähnlich sind (z. B. der gesamte IE und C) und die Zeichenfolge aus Zeichen besteht, die je nach angezeigter Version unterschiedlich angezeigt werden. zB m bedeutet "ein Schrägstrich vorwärts für die rechts aufwärts gerichtete Zeichenfolge, ein umgekehrter Schrägstrich in der umgedrehten Zeichenfolge". Es wird eine Transliterationsersetzung durchgeführt, um das richtige Zeichen anzuzeigen. Leerzeichen werden auch mit Zeichenfolgensubstitutionen in Lauflänge codiert.

mehrzeilig:

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

Idee:

Da die Ausgabe nur 22 eindeutige Spalten enthält, sollte es möglich sein, sie als 22 * ​​4 = 88 Zeichen mit einem Bereich von 0-17 (alle möglichen "Doppelbedeutungszeichen") zusammen mit einer 56-Zeichen-Suche zu speichern Tabelle mit einem Eintrag im Bereich von 0-21 pro Spalte. Theoretisch könnte dies mit <100 Bytes codiert werden, es ist jedoch schwierig, dies zu einem Nettogewinn zu machen, da der Code komplizierter zu decodieren ist.

CJAM, 206

Die beiden ASCII-Bilder sind Base-216-codiert, ein Byte = 3 Zeichen.

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

Teste es hier

Powershell, 275 253 248 Bytes

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

Testskript:

$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

Ausgabe:

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

Hauptideen

Die Komprimierungsmethode ist die erweiterte Methode von CJam von Dennis ♦:

1. Erstellen Sie eine Zeichenfolge vor der Komprimierung:
   • Zeichen der ersten Spalte beider ASCII-Künste
   • Zeichen der zweiten Spalte, dann
   • Zeichen der dritten Spalte und so weiter ...
2. Komprimieren Sie mit 10 aufeinanderfolgenden Ersetzungen (10, da Powershell die Zahlen 0..9 als Zeichenfolgen verwenden kann, wird der Dekomprimierungsalgorithmus kürzer. Ersetzungen werden durch rohe Gewalt ermittelt.)

Das Skript zur Komprimierung:

$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

Die Zeichenfolge vor der Komprimierung lautet:

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

SAS, 442 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;`

Nicht golfen:

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

Tests:

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

Könnte möglicherweise ein bisschen Code einsparen, indem sie in Eingabeblöcke eingefügt werden, aber das fügt die Einschränkung hinzu, dass das Makro nur einmal pro Datenschritt sein kann, was meiner Meinung nach den Geist des Schreibens als Makro verletzt. (Und ich vermute, das Hinzufügen einer Eingabeaufforderung, um Eingaben in den Datenschritt zu erhalten, fügt mehr Zeichen hinzu).

Bash, 247 Bytes

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

Zeichenfolgen werden verkettet und gziped.

PHP, 225 Bytes

Hässliche Brute-Force-Lösung.

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

Ich habe dann base64 komprimiert und die anzuzeigenden verketteten Zeichenfolgen codiert. Der Code dekodiert, dekomprimiert und teilt ihn in Stücke von 224 Zeichen. Die erste Zeichenfolge besteht aus 224 Zeichen ohne abschließende Zeile, die zweite aus 201 Zeichen (auch ohne nachfolgende Zeile). Die Parität des Befehlszeilenarguments ( $argv[1]%2) wird als Index in dem von generierten Array verwendet str_split().

Haskell, 138 Bytes

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

Das ist ein bisschen hacken. Ich forciere den SHA256-Hash der Concatination der beiden Minecraft-Texte und teile sie dann auf und wähle den passenden Text basierend auf Parameter x aus. Dies ist natürlich sehr unpraktisch und kann nicht in Echtzeit berechnet werden. Soweit ich weiß, kann es sogar zu Kollisionen kommen.

Da Haskell die ASCII-Darstellung dieses Hash in einer Zeichenfolge nicht haben kann, lese ich sie aus einer Datei mit dem Namen "a" und habe daher meiner Punktzahl 32 Bytes hinzugefügt.

• readFile und pack stammen aus Data.ByteString.Char8
• Hash ist von Crypto.Hash.SHA256

Erklärung:

replicateM 425"/\\|_- "

Erstellt eine Liste mit jeder Kombination der Buchstaben "/ \ | _-" aus 425 Buchstaben (die Länge beider Minecraft-Texte zusammen).

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

Wählen Sie den ersten, der zum Hash passt

take 225.drop(225*mod x 2)

Der erste Text ist 225 Buchstaben lang, der andere genau 200.

Javascript (ES6), 403 296 Bytes

(Aus meiner vorherigen Antwort ) Eine neue Methode ausprobieren:

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

Beachten Sie, dass es einige nicht druckbare Zeichen gibt. diese wurden ersetzt durch zb \x83.

Die Codierung selbst ist ca. 40 Byte kürzer als die andere, der Decodierungsprozess ist jedoch aufwändiger. Ich habe das Base-216-System verwendet, mit dem andere den Text verschlüsselt haben. Als Referenz ist hier der Code, den ich verwendet habe:

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

Dabei wird im Grunde genommen der ASCII-Text (vorkonvertiert auf Basis 6) verdreifacht und in Basis 216 geändert. Anschließend werden 53 hinzugefügt, um die meisten nicht druckbaren Zeichen zu entfernen.

Vorschläge willkommen!

Hier ist der ursprüngliche 403-Byte-Code:

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

Mit einer forSchleife, einer whileSchleife, vier Variablen, die nur einmal verwendet wurden, und einer Menge langer Algorithmen für einfache Dinge. Junge, habe ich mich verbessert ...

Python, 312 Bytes

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

Funktion druckt die Ausgabe mit einem Int

C 321 Bytes

Codierte die Wiederholung und den Zeichenindex in eine Zeichenfolge.

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 Bytes

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

Probieren Sie es online!

Ruby, 290 Bytes

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

Wahrscheinlich ein schwacher und verbesserungsfähiger Eintrag. Grundsätzlich eine sehr einfache (handgefertigte) Komprimierung, bei der Kleinbuchstaben bedeuten, dass viele Leerzeichen (tatsächlich ord (ch) - 'A' Leerzeichen) und Großbuchstaben nur einige gebräuchliche Begriffe sind, die einige Bytes einsparen.

SOGL V0.12 , 72 71 Bytes

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

Probieren Sie es hier aus!

Die vertikale Spiegelung von SOGL hat dafür perfekt funktioniert.

Canvas , 70 Byte

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

Probieren Sie es hier aus!