Stampa la favicon di Stack Exchange


19

Sfida

Stampa o restituisci la favicon di Stack Exchange, come indicato di seguito:

 ___________________
/                   \
---------------------
|                   |
---------------------
|                   |
---------------------
\__________    _____/
           |  /
           | /
           |/

Questo è , quindi vince la risposta più breve in ogni lingua.


2
L'angolo in alto a sinistra deve essere leggermente disallineato?
ETHproductions

@ETHproductions E ' stato destinato, ma sto cambiando ora. Sembra un po 'imbarazzante in entrambi i casi.
musicman523

2
L'output effettivo è di 219 byte, per riferimento.
totalmente umano il

Sono consentite le linee finali e / o gli spazi finali sulle linee, giusto?
dzaima,

Risposte:


43

Linguaggio di scripting dell'operazione Flashpoint , 263 195 byte

f={r="                   ";t="---------------------\n";s=" ___________________\n/"+r+"\\n"+t+"|"+r+"|\n"+t+"|"+r+"|\n"+t+"\__________    _____/\n           |  /\n           | /\n           |/";s}

Non è lo strumento giusto per il lavoro.

Chiama con:

hint call f;

Produzione:

La formattazione ha esito negativo, perché il carattere non è monospaziato.


49
Proprio quello che ti fa guardare una sfida e pensare "oh, dovrei rispondere che in Operation Flashpoint" mi
confonde

7
@totallyhuman Immagino che il suo linguaggio di scripting sia semplicemente divertente da scrivere. Ha alcune stranezze e limitazioni, quindi a volte è necessario utilizzare alcune strane soluzioni alternative, il che lo rende interessante (ma non molto pratico).
Steadybox

5
La risposta hardcoding probabilmente ti darebbe un punteggio migliore.
NieDzejkob,

2
@NieDzejkob Ora è più breve della semplice codifica dell'output, ma più noioso della versione precedente.
Steadybox

@totallyhuman E con questa sfida in particolare, volevo testare come sarebbe il linguaggio con una sfida alla complessità di Kolmogorov (per la quale è molto meno che ideale per).
Steadybox

11

Carbone di legna , 38 37 33 30 byte

←×_χ↓F/||⟦ι¹¹⟧\×_⁹‖B_×ψ⁴↙↙³↑↑³

Provalo online! Il collegamento è alla versione dettagliata del codice. Modifica: gestito per salvare un byte con l'aiuto di una riflessione, anche se @CarlosAlejo mostra che in realtà può essere fatto in 37 byte senza riflettere. Salvati altri 4 byte disegnando il ¾ sinistro e riflettendo il ¼ finale. Modifica: la precedente risposta a 33 byte dipendeva dal ReflectButterflyOverlap()non sovrastampare l'area di sovrapposizione con il riflesso, quindi nel caso in cui questo comportamento fosse cambiato, ho cercato una soluzione che non si basava su quello, e il risultato si è rivelato comunque più breve, grazie al mio uso creativo della stampa di un array. Spiegazione:

←×_χ                            Print 10 `_`s leftwards (top row)
    ↓                           Move down to the next row
     F/||                       For each character in the string `/||`
          ι                     Current character
           ¹¹                   Integer 11, prints as `-----------`
         ⟦   ⟧                  Put both into an array
                                Implicitly print on separate lines
              \                 Implicitly print `\`
               ×_⁹              Implicitly print 9 `_`s
                  ‖B            Reflect right, overlapping the axis
                    _           Implicitly print `_`
                     ×ψ⁴        Implicitly delete 4 characters
                        ↙↙³     Move down left and print three `/`s
                           ↑↑³  Move up and print three '|'s

2
Molto ben giocato. Adoro il fatto che ci siano quattro risposte al carbone a questa domanda! ‖BOnon era nella lingua l'ultima volta che l'ho usato - dovrò tenerlo a mente per il futuro.
DLosc,

Ho dovuto vedere di persona cosa intendevi con "riflettere l'ultimo ¼". Ben suonato davvero!
Charlie

8

/// , 98 byte

/'/  //&/
"""
|!! |//%/\\\/
!'|//#/_____//"/-------//!/'''' / ###____
\/!! \\&&
"""
\\##''#%'% %\/

Provalo online! Oppure, vederlo interattivamente!


3
Esiste un'utilità che mi consente di vedere i diversi "passaggi" di un programma ///? (Esecuzione parziale dopo ogni sostituzione). Ciò potrebbe aiutarmi a capirli meglio.
CAD97,

@ CAD97 Sono stato in giro con l'interprete online, e di solito sarebbe arrivato con opzioni di debug, ma il modo in cui l'interprete online ordina argomenti, non funziona in questo modo. Puoi prendere una copia dell'interprete e fare qualcosa di simile perl slashes.pl -d1 code.txt. Attualmente sto lavorando su un ambiente di esecuzione online per ///, ma ciò potrebbe richiedere del tempo.
Conor O'Brien,

3
@ CAD97 Detto ciò online, dai un'occhiata!
Conor O'Brien,

8

JavaScript (ES6), 113 112 byte

(Salvato un byte grazie a @Craig Ayre.)

let f=

_=>` _19
/ 19\\
-21
| 19|
-21
| 19|
-21
\\_10 4_5/
 11| 2/
 11| /
 11|/`.replace(/.(\d+)/g,([a],b)=>a.repeat(b))
 
 console.log(f());


Sembra che tu abbia uno spazio randagio prima della funzione di sostituzione. Avevo appena escogitato un aggiornamento simile per la mia soluzione JS a 113 byte. Non so se dovrei pubblicarlo o lasciarti avere.
Shaggy,

Ah, aspetta, vedendo solo ora che hai pubblicato la tua soluzione prima che io pubblicassi la mia. Eliminerò il mio quando arrivo a un computer e puoi salvare un byte con replace(/.(\d+)/g,(a,b)=>a[0].repeat(b)).
Shaggy,

Grazie Shaggy. Avevo scritto un programma per automatizzare questo tipo di risposta, ed era sciocco vederlo produrre uno spazio non necessario. La tua replaceaffermazione suggerita è sicuramente un miglioramento, che ora ho incorporato nel mio programma.
Rick Hitchcock,

1
Riuscirai a salvare una matrice di corrispondenza di byte a: ([a],b)=>a.repeat(b))?
Craig Ayre,

Sì grazie! Non avevo familiarità con quella sintassi.
Rick Hitchcock,

7

SOGL V0.12 , 32 31 byte

^$∙r↑Ψ«2τγæΕž‘╬Æ╬⁷"ƧΡ⅟?0Ξ³‘6«8ž

Provalo qui!

Spiegazione:

...‘               push a quarter of the icon
    Β             palindromize vertically
      ╬⁷           palindromize horizontally (these two should be ╬3 together, but spacing doesn't work correctly (though now it does since I fixed it))
        "...‘      push the extention
             6«8ž  at coordinates [12; 8] in the quad-palindromized image put that in

Il quartiere:

 __________
/
-----------
|
-----------

e l'altra parte:

    
|  /
| /
|/

"togethe"? "Trough"? Inoltre, ci è voluto un po 'di tempo per capire che .nella spiegazione significava string. Forse usare ^...'e "...'?
CalcolatriceFeline

@CalculatorFeline Di solito lo facevo ...per stringhe compresse (anche senza senso) ma ultimamente ho iniziato a fare uno o due. E sentiti libero di correggere i miei errori e la mia grammatica: p
dzaima,

7

Python 2 , 115 byte, idea più creativa

t,u,v,w,x,y,z='\n -/\\_|';k=w+t+11*u+z;i=t+21*v+t
print u+19*y+t+w+19*u+x+(i+z+19*u+z)*2+i+x+10*y+4*u+5*y+k+u,k,k+w

Provalo online!

Python 2 , 102 byte, idea noiosa

print'eNrjUojHBFz6CpgghksXG+CqwaK2hgpqYxDuASkDM/S5kDUqKKDxUbn6XADUmClx'.decode('base64').decode('zip')

Provalo online!


2
Sto votando in questo modo poiché ho visto questo metodo usato troppe volte. È solo noioso vedere ancora e ancora.
R. Kap

8
@ R.Kap A meno che non ci sia un modo più breve, questa è una ragione piuttosto arbitraria per votare.
Dennis,

1
@Dennis Forse, ma continuo a sostenere la mia opinione e ho tutto il diritto di esprimerla. Ho visto questo metodo usato innumerevoli volte su questo tipo di sfide e richiede poca o nessuna creatività da parte del PO, che sono aspetti importanti, almeno secondo me, delle sfide della complessità di Kolomogorov, e quindi la mia ragione per il voto negativo .
R. Kap

2
@ R.Kap Se gli algoritmi di compressione generici possono battere facilmente quelli manuali, questo è un problema della sfida, non della risposta. Non riuscivo nemmeno a battere Bubblegum con Jelly, e la decompressione aveva pochissime spese in Jelly.
Dennis,

2
@Dennis Non sto nemmeno parlando della lunghezza del codice qui. Sto parlando di sforzo e creatività, che questa risposta, a mio avviso, non riesce a mostrare in una lingua in cui si può fare molto di più, motivo per cui ho votato in negativo. Ora, se non sei d'accordo con il mio ragionamento, va bene. In tal caso, accettiamo di non essere d'accordo e terminare questa conversazione proprio qui prima che diventi troppo lunga. :)
R. Kap

6

Python 2, 124 byte

a,b,d,e,f,g,h=' _-|/\\\n';r=d*21+h+e+a*19+e+h;n=f+h+a*11+e;print a+b*19+h+f+a*19+g+h+r*2+r[:22]+g+b*10+a*4+b*5+n+a*2+n+a+n+f

Provalo online!


Non lo usi mai c, quindi puoi eliminarlo per 3 byte. Provalo online!
musicman523

@ musicman523 Non so nemmeno perché l'ho messo lì. Grazie per la cattura! :)
R. Kap

6

C (gcc) , 187 byte

Salvato 2 byte grazie a Cody Grey e 3 byte grazie a Keyu Gan!

#define a"         "
#define s a" "a
#define l"\n---------------------\n"
f(){puts(" ___________________\n/"s"\\"l"|"s"|"l"|"s"|"l"\\__________    _____/\n"a"  |  /\n"a"  | /\n"a"  |/");}

Provalo online!


2
putssarebbe banalmente più breve, se una nuova riga finale è accettabile.
Cody Gray,

puoi usare al f()posto di main(). Una funzione è anche accettabile.
Keyu Gan,

5

Ruggine , 181 byte

||" ___________________
/2\\
1
1
3
\\__________    _____/
4|  /
4| /
4|/".replace("1","3
|2|").replace("2",&" ".repeat(19)).replace("3",&"-".repeat(21)).replace("4",&" ".repeat(11))

Provalo online!

Ruggine , 184 byte

Questa versione può essere più golfabile poiché l'aggiunta di ulteriori replacecosti in meno byte ciascuno. Il primo replacenon fa parte del ciclo perché tira il doppio dovere cambiando sin a Stringinvece di a &'static str.

||{let mut s=" 5__5__5
/2\\
1
1
3
\\55    5/
4|  /
4| /
4|/".replace("1","3
|2|");for p in vec![("2"," ",19),("3","-",21),("4"," ",11),("5","_",5)]{s=s.replace(p.0,&p.1.repeat(p.2))}s}

Provalo online!


5

C, 167 byte

i;char*d=" q    /()\\   A   |()|    A   |()|    A   \\h#c/  #&|!/   #&| /   #&|/",c,b;main(j){while(c=d[i++],b=c%5==2||c>123?c:c>95?95:c>45?45:c>=32?32:++c,i<47)for(j=c;j-->=b;)putchar(b);}

Provalo online!

Nota: molti spazi apparenti sopra sono in realtà il carattere di tabulazione.

Versione leggibile:

i;
char *d = " q   /()\\   A   |()|    A   |()|    A   \\h#c/  #&|!/   #&| /   #&|/", c, b;
main(j) {
    while(
        c = d[i++],
        b = c % 5==2 || c > 123 ? c:
            c > 95 ? 95:
            c > 45 ? 45:
            c >= 32 ? 32:
            ++c,
        i < 47
    )
        for(j = c; j-- >= b;)
            putchar(b);
}

Spiegazione:

L'array di dati, d, codifica la risposta in caratteri singoli letterali e caratteri ripetuti codificati. Ogni carattere, c, nell'array di dati è associato a un carattere di base, b e un numero di ripetizioni. Viene quindi stampato più volte.

I caratteri usati solo singolarmente (barre e pipe) hanno i codici ASCII 47, 92 e 124. Due di questi sono divisibili per 5 con un resto di 2 (c%5=2||c>123). Non sono riuscito a trovare una condizione più breve per testare tutti e tre.

I caratteri ripetuti (carattere di sottolineatura, trattino e spazio), rispettivamente con i codici ASCII 95, 45 e 32, sono codificati con un codice ASCII più elevato, aumentato di uno per ripetizione. Quindi, ad esempio, un singolo spazio è solo uno spazio, ma due spazi possono essere codificati dal successivo carattere ASCII, il punto esclamativo. Laddove un carattere codificato sarebbe inadatto perché soddisfa la condizione modulo sopra, può essere diviso, come con # e per rappresentare undici spazi. La stessa tecnica viene utilizzata per evitare sovrapposizioni tra lo spazio e le gamme di caratteri del trattino.

Infine, le dieci nuove righe sono codificate come schede per salvare i byte che sarebbero stati spesi per sfuggire alle nuove righe con una barra rovesciata, quindi incrementate per la stampa ( ++c).


Molto bene! Sapevo che c'erano risposte C migliori.
musicman523

Grazie! È stata una sfida divertente. Ho trascorso qualcosa come quattro ore, quindi sono contento che alla fine abbia funzionato.
jiv

4

Carbone , 49 37 byte

↓⁵\…_χ↓↓³↗↗³…_⁵↑/↑⁵↖\←…_¹⁹↓ /F³«P²¹¶¶

Provalo online!

Finalmente ho potuto giocare a golf un po '. Questa risposta (a differenza di tutte le altre risposte al carbone) non utilizza la riflessione, ma disegna tutto il contorno in un passaggio, lasciando le barre orizzontali per la fine.

Link alla versione dettagliata .


"A differenza di tutte le altre risposte al carbone" In realtà la mia prima risposta non ha usato neanche la riflessione, ma ammetto di non aver individuato la possibilità di giocare a golf con un byte iniziando il disegno con la linea verticale sinistra. (Le uniche altre modifiche tra le nostre soluzioni sono che usi Range dove ho usato Times e stampi un punto in \cui ho appena stampato :UpLeft1 passaggio.)
Neil

Anche se sembra che la riflessione sia fino alla strada da percorrere ...
Neil

Anche questo è due volte ora che la mia chiave della s non ha funzionato ...
Neil

3

Bubblegum , 40 byte

Salvato 1 byte rimuovendo una nuova riga finale, grazie @ovs!

00000000: 5388 c704 5cfa 0a98 2086 4b17 1be0 aac1  S...\... .K.....
00000010: a2b6 860a 6a63 10ee 0129 0333 f4b9 9035  ....jc...).3...5
00000020: 2a28 a0f1 51b9 fa00                      *(..Q...

Provalo online!


Senza una nuova riga finale, questo ottiene 40 byte .
Ovs,

Grazie! Penso che il mio editor di testo ne abbia inserito automaticamente uno.
musicman523

Come hai creato questo? zlib.compress(s.encode(), 9)genera 46 byte e la risposta sembra essere zlib.
NieDzejkob,

Come suggerito da Dennis , ho usato zopfli --deflateper generare il flusso DEFLATE non elaborato, quindi xxdlo ho convertito nel formato xxd. Credo che zliblasci un checksum o non sia un flusso DEFLATE non elaborato per qualche altro motivo.
musicman523,

3

Carbone , 38 byte

←…_χP↑⁵P\F³«↑P¹¹↑»↗¹…_χ‖BM²¦⁷P↓⁴… ⁴↙↙³

Provalo online!

Ho usato la risposta di Carlos nella sua forma originale come punto di partenza, ma ho risparmiato un bel po 'usando un riflesso, sfruttando la simmetria orizzontale. (La simmetria verticale non ne valeva la pena perché i trattini bassi sono finiti sulla riga sbagliata.) Puoi vedere l'evoluzione della tela ad ogni passo qui .

Ecco la versione dettagliata .


btw puoi usare -dper mostrare ogni passo (mi dispiace anche di aver cambiato così tanto carbone, non sono sicuro che molte delle nuove idee siano molto utili, in particolare la costruzione di capri ascii-art e parte del linguaggio wolfram haha)
ASCII il


3

Python 2, 119 117 116 byte

print''.join(' \n-/|\\_'[ord(x)/8-4]*int('1245abjl'[ord(x)%8],36)for x in' V(8&H(7(@&@(7(@&@(7(HT"S8(%@!8(%@ 8(%@8')

Provalo online!

Un po 'di codifica torturata per la lunghezza ...

EDIT: salva 3 byte sostituendo il set di lunghezze:

[1,2,4,5,10,11,19,21][ord(x)%8]

con

int('1245abjl'[ord(x)%8],36)


Wow! Stavo cercando di pensare a un modo efficace per farlo da solo.
GarethPW

Bel codice, ma sembra che sia di 119 byte?
mdahmoune

@mdahmoune: Abbastanza bene - ho dimenticato di usare r''quando si controlla la lunghezza ...
Chas Brown,

3

C ++ 11-162 159 154 152 150 byte

MSVC:

void f(){char*i="b t_b\nb/t b\\b\nv-b\nb|t b|b\nv-b\nb|t b|b\nv-b\nb\\k_e f_b/b\nl b|c b/b\nl b|b b/b\nl b|b/";while(*i)cout<<string(*i++-97,*i),i++;}

GCC: (+4 caratteri)

int f(){char*i="b t_b\nb/t b\\b\nv-b\nb|t b|b\nv-b\nb|t b|b\nv-b\nb\\k_e f_b/b\nl b|c b/b\nl b|b b/b\nl b|b/";while(*i){cout<<string(*i-97,*(i+1));i+=2;}}

La stringa di input iè codificata in coppie di caratteri:

  1. Conteggio dei caratteri da ripetere (aggiunto a 'a' per essere un personaggio leggibile)
  2. Char da stampare

Penso che ci sia ancora molto margine di miglioramento qui.

Modificare:

  1. Sostituito putchar con cout <<
  2. Rimuovi while, usa il costruttore di stringhe per ripetere i caratteri
  3. Spazio rimosso prima del puntatore e di un punto e virgola spurio ;;
  4. Istruzioni di composizione con virgola, rimozione delle parentesi graffe.

C ++ 11 non supporta autocome tipo restituito, questa è una funzionalità C ++ 14. Tuttavia, è possibile risolvere questo problema e salvare un byte impostando il tipo restituito int. Tuttavia, non sembra che questo codice funzioni; potresti provarlo su Provalo online! e vedi se riesci a risolverlo?
musicman523,

Modificato il tipo di ritorno auto -> void. Stavo testando su Visual Studio 2017 - automaticamente C ++ 14. Aggiunta una versione per gcc.
Robert Andrzejuk,

Oh okay, capito. Sto usando Linux, quindi non ho VS. Bel lavoro!
musicman523,

Ciao Robert, il tuo approccio alla codifica della lunghezza è simile al mio; vedi qui . Metto inoltre ogni coppia (lunghezza, carattere) in un singolo carattere invece di 2. Vi sono 7 caratteri possibili e 8 lunghezze distinte; quindi uso i 56 caratteri ' '..'X'per la codifica; che consente di risparmiare 40 byte con un sovraccarico aggiuntivo per la decodifica.
Chas Brown,


3

Gruppo R16K1S60 , 152 144 byte

Scrive l'output sullo schermo periferico R16K1S60 in ASCII. Funziona con il salvataggio di The Powder Toy 2012356. (Vedi link nell'intestazione per informazioni)

La dimensione in byte del programma è il risultato compilato (Celle utilizzate * 2), non l'assieme.

Sai di aver fatto bene quando il logo occupa più spazio del tuo bytecode.

a:
mov ex, ip
mov ax, .string
mov sp, ip
mov dx, 0x1000
send sp, dx
.loop:
mov bx, [ax]
cmp bx, ip
je .end
cmp bx, ip
je .newline

shr bx, cx, 8
and cx, 0x00FF
.inner:
send sp, cx
sub bx, ex
jnz .inner
.reentry:
add ax, ex
jmp .loop
.newline:
add dx, 0x0020
send sp, dx
jmp .reentry
.string:
dw 0x0120
dw 0x135F
dw 0x000C
dw 0x012F
dw 0x1320
dw 0x015C
dw 0x000C
dw 0x152D
dw 0x000C
dw 0x017C
dw 0x1320
dw 0x017C
dw 0x000C
dw 0x152D
dw 0x000C
dw 0x017C
dw 0x1320
dw 0x017C
dw 0x000C
dw 0x152D
dw 0x000C
dw 0x015C
dw 0x0A5F
dw 0x0420
dw 0x055F
dw 0x012F
dw 0x000C
dw 0x0B20
dw 0x017C
dw 0x0220
dw 0x012F
dw 0x000C
dw 0x0B20
dw 0x017C
dw 0x0120
dw 0x012F
dw 0x000C
dw 0x0B20
dw 0x017C
dw 0x012F
dw 0x0009
.end:
hlt

Spiegazione

Il codice assembly sopra implementa un semplice algoritmo di compressione, con le parole 0x000C come newline e 0x0009 come comando per interrompere l'esecuzione.

Le altre parole sono codificate semplicemente, in questo modo: 0xTTCC

  • T: Tempi per ripetere il valore

  • C: il carattere ASCII da stampare

L'ASM utilizza tutti i registri disponibili, inclusi alcuni dei meno utilizzati:

  • L'istruzione Pointer, per richiamare rapidamente alcuni valori noti per salvare alcuni byte (un valore costante in un'istruzione che non è solo un registro utilizza un byte aggiuntivo per memorizzarlo)

  • Stack Pointer viene utilizzato come sesto registro per scopi generici, poiché nessuno dei codici utilizza lo stack.

Solo AX, BX, CX e DX sono effettivamente utilizzati per dati importanti. EX e SP vengono utilizzati per memorizzare alcune costanti che vengono utilizzate di frequente.

È in qualche modo semplice e ha poche possibilità di vincere, ma è stato divertente scrivere!

Vedi la cronologia delle revisioni per la vecchia risposta (è altrettanto grande in termini di ASM)

funfact: se questo fosse misurato in parole (nel caso dei bit R16K1S60,16) sarebbe più piccolo della risposta pyth, a 72 byte




2

Mathematica, 163 byte

Row@Map[Column,Characters/@{" /-|-|-\\   ",r="_ - - -_   ",r,r,r,r,r,r,r,r,r,"_ - - - |||","_ - - -   /","_ - - -  / ","_ - - - /  ",r,r,r,r,r," \\-|-|-/   "},{1}]


2

Python 2, 171 byte

p,u,q,v,r,s,F=' ','_','/','|','-'*21,'\\',lambda f,m:f+m*19+f;B=lambda n:p*11+v+p*n+q
print'\n'.join([F(p,u),q+p*19+s,r,F(v,p),r,F(v,p),r,s+u*10+p*4+u*5+q,B(2),B(1),B(0)])

Ogni riga ha esattamente 85 byte! Hoorah!


2

Zsh, 244 byte

Questo è specificamente scritto per Zsh, non per Bash, in quanto consente un po 'di più in termini di strana sintassi.

alias p=printf
function r { p "$1%.s" {0..$2}}
function l { p $1;r $2 19;p $3;p "\n"}
l " " _ " "
l / " " \\
l - - -
l \| " " \|
l - - -
l \| " " \|
l - - -
p \\
r _ 10
r " " 4
r _ 5
p "/\n"
r " " 11
p "|  /\n"
r " " 11
p "| /\n"
r " " 11
p \|/

Nota: quando ho provato a eseguirlo su tio.run l'output è diverso rispetto al mio terminale. La correzione a questo sta sostituendo

function r { p "$1%.s" {0..$2}}

con

function r { p "$1%.0s" {0..$2}}

che lo renderebbe 245 byte ( link ).

Modifica Sembra che fossi troppo ansioso di premere quel pulsante post e mi mancassero alcuni spazi, rendendo la mia soluzione un po 'meno efficiente. Il mio nuovo output sembra spento, ma penso di aver contato correttamente (ma non cambierebbe comunque la lunghezza).


Benvenuti in PPCG! Nota che la linea inferiore di caratteri di sottolineatura ha uno spazio di quattro spazi in essa, che manca nell'output del tuo codice.
Steadybox

@Steadybox Ohh sciocco me. Ho aggiornato la risposta, grazie per averlo sottolineato!
Luca_Scorpion,

Nessun problema! Sfortunatamente, penso che sia ancora un po 'spento, ma questo dovrebbe risolverlo (e ti fa risparmiare anche un byte!).
Steadybox

Penso che puoi salvare qualche byte usando 'funcname () {}' invece di 'function funcname {}'
Winny


2

Python 2, 159 153 139 byte

s=" "*19;e="-"*21;a=" "*9;print" %s\n/%s\\\n%s\n|%s|\n%s\n|%s|\n%s\n\%s    %s/\n%s|  /\n%s| /\n%s|/"%("_"*19,s,e,s,e,s,e,"_"*8,"_"*7,a,a,a)

Provalo online!

EDIT: 6 byte salvati utilizzando la %formattazione anziché .format().
EDIT: salvato altri 14 byte correggendo l'output, grazie a musicman523.


1
Questo non stampa il testo esatto (sono presenti righe extra). La correzione di questo probabilmente salverà anche alcuni byte.
officialaimm,

Ecco una versione fissa , che arriva a 139 byte caldi
musicman523

2

Japt , 79 72 71 byte

" _p
/ p\\
{"-r
| p|
"²}-r
\\_g a_b/
 h|  /
 h| /
 h|/"r".%l"_g p6nZÅnH

Provalo

  • 7 byte salvati grazie all'eccellente suggerimento di ETHproductions di utilizzare numeri interi di base 32 per i valori di ripetizione.

Metodo di compressione molto bello. Se lo usi nHpuoi salvare qualche altro byte: ethproductions.github.io/japt/…
ETHproductions

1

JavaScript (ES6), 151 byte

_=>` 2_________
/0\\
1
|0|
1
|0|
1
\\2    _____/
3|  /
3| /
3|/`.replace(/\d/g,a=>a.repeat.call(...[[" ",19],["-",21],["_",10],[" ",11]][a]))

Test dello snippet

f=
_=>` 2_________
/0\\
1
|0|
1
|0|
1
\\2    _____/
3|  /
3| /
3|/`.replace(/\d/g,a=>a.repeat.call(...[[" ",19],["-",21],["_",10],[" ",11]][a]))

O.innerHTML=f()
<pre id=O>



1

Carbone , 48 byte

↙¹→P¹¹↓↓¹P¹¹‖B↓¦↘→×¹⁰_M⁷↑←←×¹⁰_‖BJ¹¹¦⁶→×⁴ ↙↙³↑↑³

Provalo online!

Interni un po 'diversi da quelli di Carlos, anche se all'inizio non sono visibili.


1

,,, , 115 101 98 byte

Mi vergogno assolutamente che questo sia il meglio che posso produrre. >.>

"|/
"' 11×:"| /
"⇆:"|  /
"⇆'
'/'_5×' 4×'_10×92c'
'|' 19×'|'
'-21×+++++3×110⇆⊣"\
"' 19×'/'
'_19×' #
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.