Minecraft con mirroring


51

Questo è Calvin . Sto solo cercando di ottenere 20 rappresentanti in modo che questo utente possa chattare nella chatroom di PPCG Minecraft Server .

Scrivi un programma o una funzione che accetta un numero intero positivo.

Se il numero intero è pari (2, 4, 6, ...), stampa o restituisci questa stringa di arte ASCII esatta:

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

Se il numero intero è dispari (1, 3, 5, ...), stampa o restituisci questa stringa di arte ASCII esatta:

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

Si può presumere che l'input sia sempre un numero intero positivo.

In entrambi i casi di output può essere facoltativamente un numero qualsiasi di spazi finali fino al bordo destro della "T" su ciascuna riga e / o una singola riga finale finale. Nota come ci sono due colonne di spazi tra ogni lettera.

Vince il codice più breve in byte.


54
Vorrei anche eliminare Calvin se fossi un nuovo utente in cerca di rappresentante;)
Geobits il

13
@Geobits Sono io.
Calvin's Hobbies,

52
@Geobits No, sono io. Sapevo che nessuno avrebbe votato se avessi rivelato che in realtà sono io.
Ottimizzatore

19
Perché importa chi l'ha creato? Il rappresentante non dovrebbe basarsi sul contenuto del post?
palude,

19
@marsh In teoria sì. In realtà, le persone sono imperfette. Sarebbe un esperimento interessante da eseguire, con un utente ad alta reputazione creare un nuovo account per pubblicare alcune sfide per misurare la differenza nella ricezione.
Geobits,

Risposte:


23

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

Solo per divertimento ... :) (Grazie a Xufox per aver tagliato 46 byte e mi ha incoraggiato a tagliare altri 37 da solo.)

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

Chiamato come a(4)o simile. Provalo qui:

Ho condensato lo spazio bianco in stringhe di cifre da 2a 8(ad esempio 887= 23 spazi). Ogni cifra viene quindi sostituita con il numero corrispondente di spazi. 0rappresenta | |e 1rappresenta __. Tutto sommato, questo programma è più corto di 170 byte rispetto alle due stringhe combinate (203 + 227 = 430), quindi sono contento. :)

Modifica: in qualche modo, è esattamente la stessa lunghezza dell'unica altra voce a questo punto .... o_o

Edit 2: salvato po 'di spazio, cambiando n%2<1?per n%2?e scambiando le corde. Ha anche approfittato del fatto che gli inizi delle due stringhe sono gli stessi per ridurre altri 5 byte.

Modifica 3: |2| sembrava mostrarsi molto, così semplificato ogni ricorrenza x, risparmiando 7 byte. I suggerimenti di Xufox hanno tagliato altri 40 byte.

Modifica 4: il suggerimento di Xufox di sostituire \ncon interruzioni di riga effettive pagate, rimuovendo 6 byte dal totale. Passare xa 0e __a 1(inserire qui la risata malvagia), quindi combinare tutti (inserire il plurale di Regex qui), come ha fatto nella sua voce, ha salvato altri 16 byte.

Modifica 5: da quando ho scelto di utilizzare gli standard ES6, ho usato l'interpolazione di stringhe di modello personalizzate per radere 2 byte finali.


1
Quel numero deve avere qualcosa! Oltre ad essere un cubo perfetto, cioè :-) Non posso votare la tua risposta poiché non ho idea di JavaScript ...
Luis Mendo,

1
Che ne dici .replace(/\d/g,d=>' '.repeat(d))?
Sebastian Simon,

1
@ETHproductions Nice! Ora, puoi battere la mia risposta? Mancano solo 9 byte ...;) A proposito, quando conto i byte dice 289, usando lo strumento di conteggio gEdit ...
Sebastian Simon,

1
Forse usando le stringhe di template per essere in grado di effettuare interruzioni di riga effettive invece di \nsalvare un byte per interruzione di riga?
Sebastian Simon,

1
Ora ho 2 byte in meno di te. = P
Sebastian Simon,

12

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

Il numero di input è fornito da stdin.

Esecuzione di esempio:

>> a=' -/\_|';
if mod(input(''),2)
x='003C00E00E000L0005N5000I000005550I0000I0055N4UVYO26R4004400400U005300UUXO060O060003C00C30CO00IO00UUUS060S5B54000';else
x='0I2000L0000L000E05H50C0000000555000C00C00H554UVYO26R4004400400U000250WUU006O006O0I2002I00O0I0O0C0UUU006S05BT0004';end
disp(a(reshape(dec2base(base2dec(reshape(x,[],7),36),6),4,[])-47))
1
                       __    __   __             __  ___
  /\  /\    |  |\  |  |     /    |  |     /\    |     | 
 /  \/  \   |  | \ |  |--  |     |--\    /__\   |--   | 
/        \  |  |  \|  |__   \__  |   \  /    \  |     | 

1
Questo è solo pazzo lol. +1.
rayryeng - Ripristina Monica il

1
@rayryeng Sì :-) Peccato che Matlab consenta solo una base fino a 36. Un valore maggiore avrebbe consentito di risparmiare parecchi byte
Luis Mendo,

1
@LuisMendo Esattamente quello che ho pensato facendo la mia soluzione JavaScript ...
Sebastian Simon,

@Xufox in JS le funzioni btoa () e atob () sono rispettivamente codifica e decodifica base64.
applaude il

11

CJam, 158 149 145 138 byte

li2%"A+×rµ^ÅÆÿ»£ºoU#ü T^U^ÝZe<ÄÊKÞÒ£^ÛWWø5Úí§¹T^Úêer^^°^Ã}Ã^A0R2"281b7b"/
 -_\|"f=N/S3**_"_ ":T/TW%*4/zW%1m>N*1>"\/"_W%er"^W^]5OU"{i_32>T=t}/\4/zN*?

Quanto sopra usa la notazione con il cursore, poiché il codice contiene caratteri non stampabili.

Provalo online nell'interprete CJam .

Se il permalink non funziona nel tuo browser, puoi copiare il codice da questo incolla .

Esempio di esecuzione

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

Idea

Invece di codificare direttamente la stringa MINECRAFT (imbottita per ottenere una lunghezza di linea costante), codificheremo una versione "zippata" di essa, in cui sono state trasposte righe e colonne.

Dopo aver zippato e rimosso i linefeed, questa stringa (chiamiamola R ) deve essere codificata:

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

Esistono molte serie di spazi, quindi sostituiremo ogni ricorrenza di una tripletta dello spazio con un avanzamento di riga.

Questo ci lascia con sette caratteri diversi ( \n -/\_|), quindi assegniamo a ciascuno di essi un numero da 0 a 6 e consideriamo le cifre di array risultanti di un numero di base 7, che quindi codifichiamo come stringa di byte.

La decodifica funziona invertendo i passaggi dall'alto.

La stringa speculare può essere costruita da quella originale.

Se invertiamo l'ordine delle quattro righe e scambiamo i solidi, otteniamo quanto segue:

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

In qualche modo simile, ma dovremo chiaramente ruotare le righe per portare in cima la riga inferiore:

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

Sarebbe così se non fosse per quei fastidiosi caratteri di sottolineatura.

Se leggiamo la stringa originale dall'alto verso il basso e ignoriamo gli avanzamenti di riga (ottenendo così R ) e sostituiamo ogni carattere di sottolineatura seguito dallo spazio con uno spazio seguito da un carattere di sottolineatura prima di spostare le righe, questo è il risultato:

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

Molto meglio! Tutto ciò che rimane da fare sta cancellando il primo spazio della prima riga (spostamento tutti sottolineatura nella prima riga un carattere di sinistra), spostando le sottolineature fuori luogo in E e C una riga e scartando la sottolineatura sopra T .

Codice

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.

Come funziona?
Anatolyg,

@anatolyg Ho modificato la mia risposta.
Dennis,

10

Pyth - 182 byte

Utilizza un approccio di codifica di base. Dato che l'indicizzazione è modulare in Pyth, non devo nemmeno fare nulla per il pari dispari, basta metterlo nell'ordine corretto e usarlo @Q. Come bonus funziona anche con numeri negativi.

@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

Ho provato solo a codificare il primo, quindi a capovolgere e cambiare le barre, ma la prima e l'ultima riga erano troppo difficili.

Potrei salvare 6 byte inserendo byte nulli effettivi nel codice, ma questo è troppo disturbo.

Provalo online qui .

Sembra davvero male online perché la casella di output è troppo piccola e si avvolge. Consiglio di armeggiare con la console di sviluppo e di cambiare col-md-5a col-md-7.


Le due stringhe hanno un sacco di caratteri duplicati, puoi rimuovere 11 byte in questo modo .
PurkkaKoodari,

8

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

Per le modifiche precedenti, consultare la cronologia delle modifiche .

Modifica 5: Nella conversione, ho cambiato il numero associato -(ora 0) e lo spazio bianco (ora 1). Nel blocco risultante, i numeri 1, 2 e 3 non erano più utilizzati. Questo mi ha permesso di utilizzare un array con i numeri mancanti.

Modifica 6: Migliorato l'array letterale. L'ho provato in precedenza, ma ho usato 777e 77come stringhe invece di numeri e ho notato solo ora che mi ero perso.

Modifica 7: Il "codice Golfed" è una funzione, come specificato dalla domanda e non è necessario f=soddisfare questa specifica. Quindi, rimuovendolo, salvando due byte.


Eseguibile in 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);

Si basa sul sistema numerico di base 6 e ogni carattere ASCII indica un numero:

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

Quindi, ho combinato la rappresentazione numerica di ciascuna stringa ASCII. Ad esempio: quando la prima stringa ASCII contiene una /in una posizione e l' altra contiene una \nella stessa posizione , quella posizione diventa 32, che è la base 6 ( 20in decimale). Se lo converti in base 36 (per ottenere un numero di base 36 per ogni due numeri di base 6), otterrai k.

Tutto ciò è stato fatto in anticipo e la funzione sostanzialmente annulla questo processo.

Ora le due risposte JavaScript hanno entrambe un'altra risposta ciascuna, che ha lo stesso numero di byte ...


PS: Come nota per me e come riferimento per gli altri, questo è il codice che ho usato:

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

2
Accidenti, perché è ~NaN == -1?!
Sebastian Simon,

Ho anche pensato di invertire la linea ASCII stringhe per riga, per sbarazzarsi di ancora più spazi finali (ma anche salvato due byte nella sostituzione: […][x]+77, 77non ha bisogno di essere più una stringa), ma l'ulteriore inversione nel codice golfed non ne valeva la pena ...
Sebastian Simon,

Non l'ho capito quando l'ho letto per la prima volta un anno fa, ma ora vedo la tecnica. Combinare ogni coppia di caratteri in uno è molto intelligente :-) Penso che puoi sostituirlo isNaNcon 1+e ~~(i/6)con i/6|0.
ETHproductions,

Haha, ora sono un byte avanti;)
ETHproductions

@ETHproductions Bene, aspetta un secondo ... Ho appena notato che all'inizio non hai f=, ma lo faccio. Ho anche letto che è accettato per rimuoverlo, quindi lo farò da solo, e ora ho 260 byte. ;)
Sebastian Simon,

6

CJam, 136 byte

"^ASÓ8¥È÷^K¯¾/^HÕ2^ÄË1jÒÝ^D^Á0îl;)HR§û|^Ê^Þ^ÇÝÅ^ßNlz^TfÑ^Øj>À^à 4#bH\¿^Äî·íì^E^A~(¿ø³(ú´,^È(¡j>è?#'»vçPïju87)×"
265b8b[S9*'|3*+S2*]"/-_\| "+f=s4/56/ri=zN*

Quanto sopra usa la notazione con il cursore, poiché il codice contiene caratteri non stampabili.

L'alimentazione di riga è esclusivamente per "leggibilità". Provalo online nell'interprete CJam .

Se il permalink non funziona nel tuo browser, puoi copiare il codice da questo incolla .

Esempio di esecuzione

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

Idea

Questo approccio ha alcune somiglianze con quello dell'altra mia risposta , ma è molto più semplice e (piuttosto deludente) un po 'più breve.

Cerchiamo un modo per codificare la seguente stringa:

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

Dopo aver riempito ogni riga (per ottenere una lunghezza della linea costante), zippare (trasporre righe e colonne) e aver rimosso gli avanzamenti di riga, questa stringa deve essere codificata:

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

Sostituiremo ogni sottostringa " |||"con uno 0 , ogni sottostringa " "con 1 e i caratteri "/-_\| "da 2 a 7 , formando un array di 8 cifre di base, che può essere codificato come stringa di byte.

La decodifica funziona invertendo i passaggi dall'alto.

Codice

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


4

Racchetta, 443 434 386 byte

(require file/gunzip net/base64)(define(f n)(define o(open-output-bytes))(gunzip-through-ports(open-input-bytes(base64-decode #"H4sIAK8Lt1UAA22Q3Q3AIAiE352CBcwtRHLpHg7f8lubahRUDuVD5DjItrH9REgOEWgskfVMDeca1GWcSmN2WFBtlUTdzdmSOT0BpEpGnjxUAf2RmvPq1OyKGF6N5V1nvgYcWjeod/Hj8JotBRtH0qM48OeoWrBxJH23KL/dOMh4IDXe8MUbT1AqtKkBAAA="))o)(list-ref(string-split(get-output-string o)"a")(modulo n 2)))

Solo per calci.

(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 potrebbe essere necessario #lang racketeseguire la linea in DrRacket.


1
Esattamente 100 byte di sconto.
user253751

1
Dai! So che puoi arrivare anche a 343
Optimizer,

Non vedo che ciò accada a meno che non abbandoni questo approccio.
Winny,

Non è necessario utilizzare 64 caratteri di base. È possibile utilizzare solo i caratteri grezzi unicode inviati da gunzip
MilkyWay90

4

05AB1E , 179 177 176 byte

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

Provalo online.

Spiegazione:

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

è il numero compresso :

669530978249988431396781816197276307266403407188962925862194299697873953319419752813246251351417090709766331736351616127424760949905163941809417778114834562736028512279028673309866195447599979612590918985644583407413903825059942009898007791080822453262749380245316127735585410697701790387188175543639634091138422651942833048832372950797322005040161476426127678479662921265139425

Provalo online.

lo converte in Base-7 come elenco, quindi otteniamo l'elenco di cifre:

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

Provalo online.

èindicizza ogni cifra nella stringa "\n-/\_|", Jquindi unisce l'intera lista insieme, il che ci dà quanto segue:

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

Provalo online.

divide la stringa in due parti.
accetta l'input e lo indicizza (con avvolgimento automatico) per ottenere una delle due parti, che viene quindi emessa implicitamente.

Enorme grazie al compressore ASCII di @MagicOctopusUrn che è stato utilizzato per generare il numero compresso e il traslitterale Base-7. Provalo online. (Dopo di che il traslitterato è stato golfato invertendo la stringa e il numero nello stack, usando вinvece di Brenderlo un elenco di cifre e indicizzandolo nella stringa con è.


3

C, 251 byte

k(w){char*f="_-/\\|]^^^\0<&*&)&3&(&&WX&J&*&\0t_&/&3&\0`);35)I5M\0a).@7).8-;./.-\0j()(0(1+4()(*+4+4()(04+",*o=f+4,m[229]="",i=7,c=10,p;for(memset(m,32,228);i;c=*f++^(w%2&i--/2==2)*115)for(p=0;*++o;m[(w%2?4-i/6-p/57:p/57)*57+p%57]=c)p+=*o-37;printf(m);}

Questa è una funzione kche riceve un parametro e stampa il messaggio stdout.

Una versione più leggibile:

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
}

Innanzitutto, prepara un messaggio vuoto (pieno di spazi). Per ogni personaggio (es. |O -), ha un elenco di posizioni in cui posizionare quel personaggio.

Per ciascuna posizione, se è necessario stampare la versione capovolta, la posizione viene invertita. Cioè, la sua coordinata verticale yviene sostituita da 4-yo 3-y(a seconda che il carattere sia un carattere di sottolineatura). Inoltre, le direzioni delle barre vengono invertite - questo viene eseguito da un XORcon 115.

Questa struttura di controllo viene anche utilizzata per posizionare i caratteri di nuova riga: sembra più efficiente aggiungere 4 coordinate in più all'elenco piuttosto che scrivere un ciclo esplicito.


Ci sono alcuni piccoli problemi con questo sistema. Prima di tutto, la lettera finale T sembra un po 'diversa nella versione capovolta:

___ 
 |    |
 |    |
 |   _|_

Per emetterlo correttamente, il codice deve posizionare i |caratteri dopo i _caratteri.

Inoltre, per assicurarmi che la stringa di controllo contenga solo caratteri ASCII, l'ho codificata:

  • Registra le differenze tra le posizioni anziché le posizioni stesse - questo riduce l'intervallo
  • I numeri nella stringa sono stati 37aggiunti a loro, per spostarli nell'intervallo ASCII 32 ... 127. Potrei aggiungere un numero più piccolo, ma 37evito caratteri come "e \, che devono essere evitati all'interno dei letterali delle stringhe.
  • Due dei numeri erano maggiori di 127 - ad esempio, il primo -personaggio appare nella posizione 137. Per tener conto di ciò, ho aggiunto un -carattere artificiale in un'altra posizione (79), che viene successivamente sovrascritto - il personaggio |appare anche nella posizione 79.

Un'altra cosa divertente era che non potevo usare putsl'output della stringa: questo avrebbe prodotto una nuova riga finale. Quindi ho usato printfinvece.

Inoltre, il numero 57appare 4 volte nel codice golfizzato: l'espressione apparentemente prolissa (w%2?4-i/6-p/57:p/57)*57+p%57consente di eliminare la variabile y, rendendo il codice più breve.


C sembra essere un tale tipo di linguaggio "scrivi sempre questo costrutto con questo codice" ... Questo ... è ... molto ... um ... +1;)
applaudi il

3

Perl, 292 259 246 byte

$_="Svv __SS__S nnSv nnSnnn
i kjSkj hw|j h|wS /SwrhSi pq hwS |
 mSlmSlS |S| l |S|--wS |--lSSmnnlS |--S |
k ihSih jw|h j|S|__S g__S|oosjSk ih jS|ooSo|o";s/v/SSSSS/g;s/w/S|S/g;s/S/  /g;<>&1?y"g-s"\\/\\  /\\ ___ |":y"g-s"\\  \\/\\/_ /\\| ";print $_

Sfrutta il fatto che le due stringhe sono per lo più simili (ad es. L'intero IE e C) e rende la stringa di caratteri che vengono visualizzati in modo diverso a seconda della versione visualizzata. ad es. m significa "una barra in avanti per la stringa di destra, una barra all'indietro in quella rovesciata". Sostituisce la traslitterazione per visualizzare il carattere corretto. Gli spazi sono inoltre codificati in base alla lunghezza usando sostituzioni di stringhe.

multi-line:

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

Idea:

Poiché nell'output sono presenti solo 22 colonne univoche, dovrebbe essere possibile memorizzarlo come 22 * ​​4 = 88 caratteri con un intervallo di 0-17 (tutti i possibili caratteri "a doppio significato"), insieme a una ricerca di 56 caratteri tabella con una voce nell'intervallo 0-21 per colonna. In teoria questo potrebbe essere codificato con <100 byte, tuttavia è difficile renderlo una vincita netta a causa del codice più complicato per decodificarlo.



2

CJAM, 206

Le due immagini ASCII sono codificate in base 216, un byte = 3 caratteri.

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

Provalo qui


2

PowerShell 275 253 248 byte

param($n)$d='8 \83484/7/484302 92984308 92918--118--128||6//0\16116129558| \/ |8 /02083\6/10018/6\302 955776_71 9_7_'
'8\,__,777,/6 /,\6/6\,_8 -- _,88,888,  ,||||||'-split','|%{$d=$d-replace+$i++,$_}
0..3|%{$l=$_;-join$d[(0..55|%{$_*8+$l*2+$n%2})]}

Script di prova:

$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

Produzione:

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

Idee principali

Il metodo di compressione è il metodo esteso di CJam di Dennis ♦:

  1. Crea una stringa prima della compressione:
    • caratteri della prima colonna di entrambe le arti ASCII, quindi
    • caratteri della seconda colonna, quindi
    • caratteri della terza colonna e così via ...
  2. Comprimi usando 10 sostituzioni consecutive (10 perché Powershell può usare i numeri 0..9 come stringhe, questo rende l'algoritmo di decompressione più breve. Sostituzioni trovate dalla forza bruta.)

Lo script per la compressione:

$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

La stringa di compressione precedente è:

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

La spiegazione nella tua risposta è stata probabilmente più impegnativa di tutte le mie risposte combinate! +1
MilkyWay90

1

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

Non-giocato a golf:

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

test:

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

Potrebbe forse salvare un po 'di codice inserendoli in blocchi di input, ma ciò aggiunge la restrizione che la macro può essere solo una volta per datastep che ritengo violi lo spirito di scriverla come macro. (E sospetto che l'aggiunta di un prompt per ottenere input nel datastep aggiunga più caratteri).


1

bash, 247 byte

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

Le stringhe vengono concatenate e decompresse.


1

PHP, 225 byte

Brutta soluzione a forza bruta.

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

Ho compresso quindi la base64 ha codificato le stringhe concatenate da visualizzare. Il codice decodifica, decomprime e lo divide in pezzi di 224 caratteri. La prima stringa è di 224 caratteri senza una nuova riga finale, la seconda è di 201 caratteri (anche dopo nessuna riga nuova). La parità dell'argomento della riga di comando ( $argv[1]%2) viene utilizzata come indice nella matrice generata da str_split().


1

Haskell, 138 byte

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

Questo è un po 'un trucco. Sto violando bruscamente l'hash SHA256 della concatinazione dei due testi di Minecraft, quindi li divido e scelgo il testo appropriato in base al parametro x. Ciò è molto poco pratico e non può essere calcolato in tempo reale, e potrebbero esserci persino delle collisioni lungo la strada per tutto ciò che conosco.

Poiché Haskell non può avere la rappresentazione ASCII di quell'hash in una stringa, la sto leggendo da un file chiamato "a" e quindi ho aggiunto 32 byte al mio punteggio.

  • readFile e pack provengono da Data.ByteString.Char8
  • l'hash è di Crypto.Hash.SHA256

spiegazione:

replicateM 425"/\\|_- "

Crea un elenco di ogni combinazione delle lettere "/ \ | _-" su 425 lettere (la lunghezza di entrambi i testi di Minecraft combinati)

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

Scegli il primo che corrisponde all'hash

take 225.drop(225*mod x 2)

Il primo testo è lungo 225 lettere, l'altro è esattamente 200.


106 byte, non 138
cat

Vedi la mia spiegazione, ho aggiunto 32 byte perché sto leggendo un file lungo 32 byte
BlackCap

1

Javascript (ES6), 403 296 byte

(Spostato dalla mia risposta precedente ) Provando un nuovo metodo:

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

Nota che ci sono alcuni caratteri non stampabili; questi sono stati sostituiti con es \x83.

La codifica stessa è di circa 40 byte più corta dell'altra, ma il processo di decodifica è più elaborato. Ho usato il sistema base-216 che altri hanno usato per codificare il testo. Per riferimento, ecco il codice che ho usato:

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

Questo in pratica prende il testo ASCII (pre-convertito in base 6) e lo triplica su se stesso, cambiandolo in base 216. 53 viene quindi aggiunto per rimuovere la maggior parte dei caratteri non stampabili.

Suggerimenti benvenuti!


Ecco il codice originale di 403 byte:

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

Usando un forloop, un whileloop, quattro variabili che sono state usate solo una volta e una tonnellata di algoritmi lunghi per cose semplici. Ragazzo, ho migliorato ...


Probabilmente puoi rimuovere completamente y=[' ','/','|','\\','_','-'],e invece di y[x]scrivere ' /|\\_-'[x]. =)
Sebastian Simon,

@Xufox L'ho fatto e molto altro, giocando a golf 107 byte in totale!
ETHproductions

0

Python, 312 byte

def y(b):
 x=int(['4vwhclv10tuk4z18gf73aimn6zvwkrhxekphfn1lxocj9ezchd1cd1cv97p3f6k12s8hcjznnm5iq3om4vgxvugp3makgu4n3f6qxvdrtl4c0lva12hwt','8uzwdylhtrf6oqnwnck8pfxu25m5844tuo2700v3zoeuvossx1b47rnwyrmqodau3feu3spi9jydhyxvntv48vojx9iq9af78wufzn1'][b%2],36);x<<=69;s="";t=" /\\-|_\n"
 while x:s+=t[x&7];x>>=3
 print s

La funzione stampa l'output dato un int


Sì, sto solo cercando un modo pulito per comprimerlo ulteriormente, poi però
Blue

Come funziona?
Oliver Ni

È base-36? ma se è cosa 16598125653940296495007405984048067937906981182427207589486265398555496561913976121109917896233762115477615438181875147062369253802653987802486539858466848179256705775331854915993645
Oliver Ni

Fondamentalmente, memorizza i due risultati in un elenco e quindi ottiene quello corretto utilizzando la funzione del modulo. Quindi decodifica dalla base 36 come pensavi. Poiché era un grande potere di 2, ho rimosso alcuni caratteri facendo >> 69. Quindi uso una funzione di traduzione di base per trasformarla nell'output corretto.
Blu

0

C, 321 byte

Codifica la ripetizione e l'indice dei caratteri in una stringa.

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

0

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

0

PHP , 263 byte

<?=strtr('3333 20220'.['2 0332 020_
2/\2/\211\113/2113/\212 1
 /2\/2\ 11 \ |1412 14\22/0\ 14 1
/32 \112\|102 \012 \2/22\12 1',
'
\32 /112/|13/212 /2\ 0 /12 1
 \2/\2/ 11 / |1412 14/22\2/ 14 1
2\/2\/211/1102 \010|3\/2102_|_'][$argn&1],[__,"  |","  ","     ","--"]);

Provalo online!


È possibile salvare altri otto byte con una propria sostituzione per 3 spazi.
Tito

0

Rubino, 290 byte

$><<(gets.to_i%2<1?"xCeCdCnCcC_
c/Bc/Be|ABAAf/e|Af/Be|f|
b/cB/cBd|AbBb|A--Af|--Be/CBd|--d|
/iBAAcB|ACdBCAdBc/eBAf|":"xCeC
Bi/AAc/|Af/e|d/cBbCb/Af|
bBc/Bc/d|Ab/b|A--Af|--/eBc/d|--d|
cB/cB/e|A/AACdBCAC|fB/e|Cc_|_").gsub(?C,'__').tr(?B,?\\).gsub(?A,'c|').gsub(/[a-z]/){|e|' '*(e.ord-97)}

Probabilmente una voce debole e migliorabile. Fondamentalmente una compressione molto semplice (realizzata a mano) in cui le lettere minuscole significano che molti spazi (in realtà ord (ch) - spazi 'A') e lettere maiuscole sono solo alcuni termini comuni che hanno salvato alcuni byte.


0

SOGL V0.12 , 72 71 byte

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

Provalo qui!

Il mirroring verticale SOGL ha funzionato perfettamente per questo.


0

Tela , 70 byte

C<aT[≤^5t‽◂6Zr!v↓[u0F∙OF-╫#t┬a*7ZfK1!&)y@½(+M⇵PV-¼G:Uju╋╷(╫:N‟‾)n⁸2%?↕

Provalo qui!

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.