To jest Calvin . Próbuję uzyskać 20 powtórzeń, aby ten użytkownik mógł czatować w pokoju rozmów PPCG Minecraft Server .

Napisz program lub funkcję, która przyjmuje dodatnią liczbę całkowitą.

Jeśli liczba całkowita jest parzysta (2, 4, 6, ...), wydrukuj lub zwróć ten ciąg artystyczny ASCII:

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

Jeśli liczba całkowita jest nieparzysta (1, 3, 5, ...), wydrukuj lub zwróć ten ciąg artystyczny ASCII:

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

Możesz założyć, że wejście jest zawsze dodatnią liczbą całkowitą.

W obu przypadkach wyjściowych może opcjonalnie być dowolna liczba końcowych spacji do prawej krawędzi litery „T” w każdej linii i / lub pojedyncza nowa linia kończąca. Zwróć uwagę, że pomiędzy każdą literą znajdują się dwie kolumny spacji.

Najkrótszy kod w bajtach wygrywa.

JavaScript (ES6), 343 336 289 267 265 260 bajtów

Po prostu dla zabawy ... :) (Dzięki Xufox za odcięcie 46 bajtów i zachęcenie mnie do samodzielnego odcięcia kolejnych 37 bajtów).

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

Nazywany jako a(4)lub podobny. Wypróbuj tutaj:

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>

Skondensowałem białe znaki w ciągi cyfr od 2do 8(np. 887= 23 spacje). Każda cyfra jest następnie zastępowana odpowiednią liczbą spacji. 0reprezentuje | |i 1reprezentuje __. Podsumowując, ten program jest o 170 bajtów krótszy niż dwa połączone łańcuchy (203 + 227 = 430), więc jestem szczęśliwy. :)

Edycja: Jakoś ma dokładnie taką samą długość jak jedyny inny wpis w tym momencie ... o_o

Edit 2: Zapisane trochę miejsca, zmieniając n%2<1?się n%2?i wymiany strun. Skorzystał również z faktu, że początki dwóch ciągów są takie same, aby zmniejszyć kolejne 5 bajtów.

Edycja 3: |2| wydawało się, że wyświetla się strasznie dużo, więc uprościłem każde wystąpienie x, oszczędzając 7 bajtów. Sugestie Xufox odcięły kolejne 40 bajtów.

Edycja 4: Sugestia Xufox, by zastąpić \nrzeczywistymi opłaconymi podziałami linii, usuwając 6 bajtów z całości. Zmieniających xsię 0i __do 1(wstawić zło śmiech tutaj), a następnie łącząc wszystkie (wstawić mnogiej Regex tutaj), jak to uczynił w swoim wejściu, zapisane dodatkowe 16 bajtów.

Edycja 5: Ponieważ zdecydowałem się na użycie standardów ES6, użyłem niestandardowej interpolacji ciągów szablonów, aby zgolić 2 ostatnie bajty.

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

Numer wejściowy jest dostarczany ze standardowego wejścia.

Przykładowy przebieg:

>> 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 bajtów

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

W powyższym użyto notacji karetką, ponieważ kod zawiera znaki niedrukowalne.

Wypróbuj online w interpretatorze CJam .

Jeśli bezpośredni link nie działa w przeglądarce, możesz skopiować kod z tej pasty .

Przykładowy przebieg

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

Pomysł

Zamiast bezpośredniego kodowania ciągu MINECRAFT (wypełnionego w celu uzyskania stałej długości linii), zakodujemy jego wersję „spakowaną”, w której transponowano wiersze i kolumny.

Po skompresowaniu i usunięciu linii, ten ciąg (nazwijmy go R ) musi zostać zakodowany:

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

Istnieje wiele przebiegów spacji, dlatego każde wystąpienie tripletu kosmicznego zastąpimy wysuwem linii.

Pozostaje nam siedem różnych znaków ( \n -/\_|), więc przypisujemy każdemu z nich liczbę od 0 do 6 i rozważamy wynikowe cyfry tablicowe liczby podstawowej 7, które następnie kodujemy jako ciąg bajtów.

Dekodowanie działa poprzez odwrócenie kroków od góry.

Lustrzany ciąg może być zbudowany z oryginalnego.

Jeśli odwrócimy kolejność czterech wierszy i zamienimy bryły, otrzymamy:

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

Jakoś podobnie, ale oczywiście będziemy musieli obrócić rzędy, aby dolny rząd znalazł się na górze:

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

Tak byłoby, gdyby nie te nieznośne podkreślenia.

Jeśli przeczytamy oryginalny ciąg znaków od góry do dołu i zignorujemy przesunięcia wiersza (otrzymując w ten sposób R ) i zastąpimy każdy znak podkreślenia, a następnie spację, spacją, a następnie znakiem podkreślenia przed przesunięciem wierszy, jest to wynik:

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

Dużo lepiej! Wszystko, co pozostało do zrobienia jest usunięcie pierwszego miejsca w pierwszym rzędzie (przerzutki wszystkie podkreślenia w pierwszym rzędzie jeden znak po lewej), przesuwając zagubionych podkreślenia w E i C jeden wiersz w górę i odrzucając podkreślenia nad T .

Kod

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 bajty

Używa podstawowego kodowania. Ponieważ indeksowanie w Pyth jest modułowe, nie muszę nawet robić nic nieparzystego, po prostu ustaw go w odpowiedniej kolejności i używaj @Q. Jako bonus działa to również z liczbami ujemnymi.

@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

Próbowałem tylko zakodować pierwszy, potem przerzucać i zamieniać ukośniki, ale pierwsza i ostatnia linia były zbyt trudne.

Mógłbym zaoszczędzić 6 bajtów, umieszczając w kodzie rzeczywiste bajty puste, ale to zbyt duży problem.

Wypróbuj online tutaj .

Wygląda naprawdę źle online, ponieważ pole wyjściowe jest zbyt małe i się zawija. Polecam błahy z dev-konsoli i zmieniając col-md-5Do col-md-7.

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

W przypadku poprzednich edycji zobacz historię edycji .

Edycja 5: W konwersji zamieniłem liczbę związaną z -(teraz 0) i białą spacją (teraz 1). W powstałym bloku liczby 1, 2 i 3 nie były już tak często używane. To pozwoliło mi użyć tablicy z brakującymi liczbami.

Edycja 6: Poprawiono literał tablicowy. Próbowałem tego wcześniej, ale użyłem 777i 77jako ciągów zamiast liczb i zauważyłem dopiero teraz, że tego przegapiłem.

Edycja 7: „Kod do gry w golfa” jest funkcją określoną w pytaniu i nie ma potrzeby f=spełnienia tej specyfikacji. W ten sposób usuwając go, oszczędzasz dwa bajty.

Uruchamiany w przeglądarce 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);

Opiera się na podstawowym systemie liczbowym 6, a każda postać ASCII oznacza liczbę:

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

Następnie połączyłem reprezentację liczbową każdego ciągu ASCII. Na przykład: gdy pierwszy ciąg ASCII zawiera /w jednej pozycji, a drugi zawiera \w tej samej pozycji , pozycja ta staje się 32, która jest podstawą 6 ( 20w systemie dziesiętnym). Jeśli przekonwertujesz to na bazę 36 (aby uzyskać jedną liczbę base-36 na każde dwie liczby base-6), otrzymasz k.

Wszystko to zostało zrobione wcześniej, a funkcja zasadniczo anuluje ten proces.

Teraz obie odpowiedzi JavaScript mają jedną odpowiedź, która ma tę samą liczbę bajtów…

PS: Jako notatkę dla mnie i odniesienie do innych, użyłem tego kodu:

// 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 bajtów

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

W powyższym użyto notacji karetką, ponieważ kod zawiera znaki niedrukowalne.

Kanał służy wyłącznie do „czytelności”. Wypróbuj online w interpretatorze CJam .

Jeśli bezpośredni link nie działa w przeglądarce, możesz skopiować kod z tej pasty .

Przykładowy przebieg

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

Pomysł

To podejście ma pewne podobieństwa do tego w mojej drugiej odpowiedzi , ale jest o wiele prostsze i (raczej rozczarowujące) nieco krótsze.

Szukamy sposobu na zakodowanie następującego ciągu:

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

Po wypełnieniu każdego wiersza (w celu uzyskania stałej długości linii), skompresowaniu (transponowaniu wierszy i kolumn) i usunięciu kanałów, ciąg ten należy zakodować:

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

My zastąpienia każdego podciągu " |||"za pomocą 0 , każdy podciąg " "z 1 i znaków "/-_\| "o 2 do 7 , tworząc tablicę podstawy 8 cyfr, które mogą być zakodowane w postaci ciągu bajtów.

Dekodowanie działa poprzez odwrócenie kroków od góry.

Kod

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

Rakieta, 443 434 386 bajtów

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

Tylko dla kopnięć.

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

Uwaga: może być konieczne uruchomienie #lang racketlinii w DrRacket.

05AB1E , 179 177 176 bajtów

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

Wypróbuj online.

Wyjaśnienie:

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

jest liczbą skompresowaną :

669530978249988431396781816197276307266403407188962925862194299697873953319419752813246251351417090709766331736351616127424760949905163941809417778114834562736028512279028673309866195447599979612590918985644583407413903825059942009898007791080822453262749380245316127735585410697701790387188175543639634091138422651942833048832372950797322005040161476426127678479662921265139425

Wypróbuj online.

7в konwertuje go do Base-7 jako listę, więc otrzymujemy listę cyfr:

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

Wypróbuj online.

èindeksuje każdą cyfrę w ciągu "\n-/\_|", a Jnastępnie łączy całą listę razem, co daje nam następujące:

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

Wypróbuj online.

2ädzieli ciąg na dwie części.
Ièweź dane wejściowe i zindeksuj je (z automatycznym zawijaniem), aby uzyskać jedną z dwóch części, która jest następnie generowana niejawnie.

Ogromne podziękowania dla kompresora ASCII @MagicOctopusUrn , który został użyty do wygenerowania skompresowanej liczby i transliteracji Base-7. Wypróbuj online. (Po czym transliteracja została zagrana w golfa poprzez odwrócenie łańcucha i liczby na stosie, вzamiast zamiast Bzrobić listę cyfr i indeksować do łańcucha za pomocą è.

C, 251 bajtów

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

Jest to funkcja, kktóra odbiera parametr i drukuje wiadomość stdout.

Bardziej czytelna wersja:

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
}

Najpierw przygotowuje pustą wiadomość (wypełnioną spacjami). Dla każdego znaku (np. |Lub -) ma on listę pozycji, w których należy umieścić ten znak.

Jeśli dla każdej pozycji należy wydrukować wersję odwróconą, pozycja jest odwracana. Oznacza to, że jego współrzędna pionowa yjest zastępowana przez 4-ylub 3-y(w zależności od tego, czy znak jest znakiem podkreślenia). Kierunki ukośników są również odwracane - odbywa się to za XORpomocą 115.

Ta struktura kontrolna służy również do umieszczania znaków nowej linii - wydaje się, że bardziej efektywne jest dodanie do listy 4 dodatkowych współrzędnych niż napisanie wyraźnej pętli.

Istnieje kilka drobnych usterek w tym systemie. Po pierwsze, ostatnia litera T wygląda nieco inaczej w wersji odwróconej:

___ 
 |    |
 |    |
 |   _|_

Aby wyprowadzić go poprawnie, kod musi umieszczać |znaki po _znakach.

Ponadto, aby upewnić się, że łańcuch kontrolny zawiera tylko znaki ASCII, kodowałem go:

• Rejestruje różnice między pozycjami zamiast samych pozycji - zmniejsza to zasięg
• Liczby w ciągu zostały 37dodane do nich, aby przenieść je do zakresu ASCII 32 ... 127. Mógłbym dodać mniejszą liczbę, ale 37unika znaków takich jak "i \, które muszą być poprzedzone literami ciągów.
• Dwie liczby były większe niż 127 - na przykład pierwszy -znak pojawia się na pozycji 137. Aby to wyjaśnić, dodałem sztuczny -znak na innej pozycji (79), która jest później nadpisywana - postać |pojawia się również na pozycji 79.

Kolejną zabawną rzeczą było to, że nie mogłem użyć putsdo wyprowadzenia łańcucha - spowodowałoby to dodanie nowej linii końcowej. Więc użyłem printfzamiast tego.

Ponadto liczba 57pojawia się 4 razy w kodzie golfowym - pozornie długie wyrażenie (w%2?4-i/6-p/57:p/57)*57+p%57pozwala wyeliminować zmienną y, co powoduje, że kod jest krótszy.

Perl, 292 259 246 bajtów

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

Wykorzystuje fakt, że dwa ciągi są w większości podobne (np. Cała IE i C) i sprawia, że ​​ciąg znaków składa się ze znaków wyświetlanych w różny sposób w zależności od wyświetlanej wersji. np. m oznacza „cięcie do przodu dla ciągu skierowanego w górę, cięcie do tyłu w odwróconym”. Dokonuje podstawienia transliteracji, aby wyświetlić poprawny znak. Spacje są również kodowane w czasie wykonywania za pomocą podstawień łańcuchowych.

wieloliniowy:

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

Pomysł:

Ponieważ w wyniku są tylko 22 unikalne kolumny, powinno być możliwe zapisanie go jako 22 * ​​4 = 88 znaków o zakresie 0-17 (wszystkie możliwe znaki „podwójnego znaczenia”), wraz z wyszukiwaniem 56 znaków tabela z jednym wpisem w zakresie 0–21 na kolumnę. Teoretycznie można to zakodować za pomocą <100 bajtów, jednak ciężko jest sprawić, aby wygrana netto była większa z powodu bardziej skomplikowanego kodu do jej odkodowania.

CJAM, 206

Dwa obrazy ascii są zakodowane w bazie 216, jeden bajt = 3 znaki.

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

Sprawdź to tutaj

PowerShell, 275 253 248 bajtów

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

Skrypt testowy:

$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

Wynik:

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

Główne pomysły

Metoda kompresji jest rozszerzoną metodą CJam autorstwa Dennisa ♦:

1. Utwórz ciąg przed kompresją:
   • znaki pierwszej kolumny obu sztuk ASCII
   • znaki drugiej kolumny
   • znaki z trzeciej kolumny i tak dalej ...
2. Kompresuj za pomocą 10 kolejnych zamienników (10, ponieważ Powershell może używać liczb 0..9 jako ciągów, co powoduje, że algorytm dekompresyjny jest krótszy. Zastąpienia znalezione przez brutalną siłę.)

Skrypt do kompresji:

$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

Ciąg przed kompresją to:

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

SAS, 442 bajty

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

Nie golfa:

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

Testy:

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

Mógłbym ewentualnie zaoszczędzić trochę kodu, umieszczając je w blokach wejściowych, ale to dodaje ograniczenie, że makro może być tylko raz na etap danych, co, jak sądzę, narusza ducha pisania go jako makro. (Podejrzewam, że dodanie zachęty w celu uzyskania danych wejściowych w kroku danych dodaje więcej znaków).

bash, 247 bajtów

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

Ciągi są łączone i gzipowane.

PHP, 225 bajtów

Brzydkie, brutalne rozwiązanie.

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

Skompresowałem, a następnie base64 zakodowałem połączone łańcuchy do wyświetlenia. Kod dekoduje, dekompresuje i dzieli go na 224 znaki. Pierwszy ciąg ma 224 znaki bez końca nowej linii, drugi to 201 znaków (również bez nowej linii po nim). Parzystość argumentu wiersza poleceń ( $argv[1]%2) jest używana jako indeks w tablicy generowanej przez str_split().

Haskell, 138 bajtów

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

To trochę hack. Brutalnie forsuję skrót SHA256 połączenia dwóch tekstów minecrafta, a następnie dzielę je i wybieram odpowiedni tekst na podstawie parametru x. Jest to bardzo niepraktyczne i nie można go obliczyć w czasie rzeczywistym, a po drodze mogą nawet wystąpić kolizje.

Ponieważ Haskell nie może mieć reprezentacji ASCII tego skrótu w ciągu, czytam go z pliku o nazwie „a” i dlatego dodałem 32 bajty do mojego wyniku.

• readFile i pack pochodzą z Data.ByteString.Char8
• skrót pochodzi z Crypto.Hash.SHA256

Wyjaśnienie:

replicateM 425"/\\|_- "

Tworzy listę każdej kombinacji liter „/ \ | _-” na 425 literach (łączna długość obu tekstów minecrafta)

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

Wybierz pierwszy, który pasuje do skrótu

take 225.drop(225*mod x 2)

Pierwszy tekst ma 225 liter, drugi dokładnie 200.

JavaScript (ES6), 403 296 bajtów

(Przeniesiono z mojej poprzedniej odpowiedzi ) Wypróbowanie nowej metody:

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

Zauważ, że istnieje kilka znaków, których nie można wydrukować; zostały one zastąpione np \x83.

Sam kodowanie jest o około 40 bajtów krótsze od drugiego, ale proces dekodowania jest bardziej skomplikowany. Użyłem systemu base-216, którego inni używali do kodowania tekstu. W celach informacyjnych oto kod, którego użyłem:

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

To w zasadzie pobiera tekst ASCII (wstępnie przekonwertowany na bazę 6) i potroi go na sobie, zmieniając go na bazę 216. Następnie dodaje się 53, aby usunąć większość znaków niedrukowalnych.

Sugestie mile widziane!

Oto oryginalny 403-bajtowy kod:

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

Korzystanie z forpętli, whilepętli, czterech zmiennych, które były używane tylko raz, i mnóstwo długich algorytmów do prostych rzeczy. Chłopcze, czy poprawiłem ...

Python, 312 bajtów

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

Funkcja drukuje dane wyjściowe z podaną liczbą całkowitą

C, 321 bajtów

Zakodowano powtórzenie i indeks znaków w ciągu.

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 bajtów

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

Wypróbuj online!

Rubinowy, 290 bajtów

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

Prawdopodobnie słaby i możliwy do ulepszenia wpis. Zasadniczo bardzo prosta (ręcznie) kompresja, w której małe litery oznaczają, że wiele spacji (właściwie ord (ch) - spacje „A”) i wielkie litery to tylko niektóre typowe terminy, które pozwoliły zaoszczędzić kilka bajtów.

SOGL V0.12 , 72 71 bajtów

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

Wypróbuj tutaj!

Lustro pionowe SOGL działało idealnie do tego.

Płótno , 70 bajtów

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

Wypróbuj tutaj!