Imprimir o favicon Stack Exchange

19

Desafio

Imprima ou retorne o favicon Stack Exchange, conforme fornecido abaixo:

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

Isso é código-golfe , então a resposta mais curta em cada idioma vence.

code-golf  string  ascii-art  kolmogorov-complexity 
— musicman523
fonte
2
O canto superior esquerdo deve estar ligeiramente desalinhado?
— ETHproductions
@ETHproductions Ele foi destinado, mas eu estou mudando agora. Parece meio estranho de qualquer maneira.
— musicman523
2
A saída real é 219 bytes, para referência.
— totallyhuman
Linhas à direita e / ou espaços à direita nas linhas são permitidas, certo?
— Dzaima 01/07
11
— Taylor Scott

Respostas:

43

Linguagem de script da operação Flashpoint , 263 195 bytes

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

Não é a ferramenta certa para o trabalho.

Ligue para:

hint call f;

Resultado:

A formatação falha, porque a fonte não é monoespaçada.

— Steadybox
fonte
49
Apenas o que faz você olhar para um desafio e pensar "oh, eu deveria responder a isso em Operation Flashpoint" puzzles me ...
— totallyhuman
7
@totallyhuman Eu acho que seu idioma de script é divertido de escrever. Ele tem algumas peculiaridades e limitações, então às vezes você precisa usar algumas soluções estranhas, o que o torna interessante (mas não muito prático).
— Steadybox
5
Codificar a resposta provavelmente daria uma pontuação melhor.
— NieDzejkob 01/07/19
2
@NieDzejkob Agora é mais curto do que apenas codificar a saída, mas mais chato que a versão anterior.
— Steadybox 01/07/19
@totallyhuman E com esse desafio em particular, eu queria testar como o idioma se sairia com um desafio de complexidade Kolmogorov (para o qual é muito menos do que o ideal).
— Steadybox
11

Carvão , 38 37 33 30 bytes

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

Experimente online!Link é a versão detalhada do código. Edit: Conseguiu salvar um byte com a ajuda de uma reflexão, embora @CarlosAlejo mostre que na verdade isso pode ser feito em 37 bytes sem refletir. Salvou mais 4 bytes desenhando a esquerda refl e refletindo a final ¼. Editar: a resposta anterior de 33 bytes dependia de ReflectButterflyOverlap()não imprimir a área de sobreposição com a reflexão; portanto, caso esse comportamento tenha mudado, procurei uma solução que não dependesse disso, e o resultado acabou sendo mais curto, graças à minha uso criativo de imprimir uma matriz. Explicação:

←×_χ                            Print 10 `_`s leftwards (top row)
    ↓                           Move down to the next row
     Ｆ/||                       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
                  ‖Ｂ            Reflect right, overlapping the axis
                    _           Implicitly print `_`
                     ×ψ⁴        Implicitly delete 4 characters
                        ↙↙³     Move down left and print three `/`s
                           ↑↑³  Move up and print three '|'s
— Neil
fonte
2
Muito bem jogado. Eu amo que há quatro respostas de carvão para esta pergunta! ‖ＢＯnão estava no idioma da última vez que o usei - vou ter que ter isso em mente para o futuro.
— DLosc
Eu tive que ver por mim mesmo o que você quis dizer com "refletir o final ¼". Bem jogado de fato!
— 307 Charlie
8

/// , 98 bytes

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

Experimente online! Ou, veja-o interativamente!

— Conor O'Brien
fonte
3
Existe um utilitário que me permita ver os diferentes "passos" de um programa ///? (Execução parcial após cada substituição.) Isso poderia me ajudar a entendê-los melhor.
— CAD97
@ CAD97 Eu tenho mexido com o intérprete on-line, e ele geralmente vem com opções de depuração, mas da maneira como o intérprete on-line ordena argumentos, ele não funciona dessa maneira. Você pode pegar uma cópia do intérprete e fazer algo assim perl slashes.pl -d1 code.txt. Atualmente, estou trabalhando em um ambiente de execução online para ///, mas isso pode levar algum tempo.
— Conor O'Brien
3
@ CAD97 Disse que coisa on-line acabou, dê uma olhada!
— Conor O'Brien
8

JavaScript (ES6), 113 112 bytes

(Salvo um byte graças 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());
Expandir snippet

— Rick Hitchcock
fonte
Parece que você tem um espaço perdido antes da função de substituição. Eu tinha acabado de apresentar uma atualização semelhante para a minha solução JS em 113 bytes. Não sei se devo publicá-lo ou deixá-lo.
— Shaggy
Ah, espere, só vendo agora que você postou sua solução antes de eu postar a minha. Excluirei o meu quando chegar a um computador e você poderá salvar um byte replace(/.(\d+)/g,(a,b)=>a[0].repeat(b)).
— Shaggy
Obrigado, Shaggy. Eu tinha escrito um programa para automatizar esse tipo de resposta, e era bobagem tê-lo produzindo um espaço desnecessário. Sua replaceafirmação sugerida é certamente uma melhoria, que agora incorporei no meu programa.
— Rick Hitchcock
11
Você pode salvar um correspondente matriz de bytes a: ([a],b)=>a.repeat(b))?
— Craig Ayre
Sim obrigado! Eu não estava familiarizado com essa sintaxe.
— Rick Hitchcock
7

SOGL V0.12 , 32 31 bytes

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

Experimente aqui!

Explicação:

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

O trimestre:

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

e a outra parte:

    
|  /
| /
|/
— dzaima
fonte
"juntos"? "vale"? Além disso, demorou um pouco para descobrir .o significado da explicação string. Talvez use ^...'e "...'?
— CalculadoraFeline
@CalculatorFeline Eu normalmente fazia ...para strings compactadas (também conhecidas como bobagens), mas ultimamente comecei a fazer uma ou duas. E sinta-se livre para corrigir meus erros e gramática: p
— dzaima
7

Python 2 , 115 bytes, ideia mais criativa

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

Experimente online!

Python 2 , 102 bytes, ideia chata

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

Experimente online!

— mdahmoune
fonte
2
Estou votando para baixo desde que eu já vi esse método usado muitas vezes. É chato ver repetidas vezes.
— R. Kap
8
@ R.Kap A menos que haja uma maneira mais curta, essa é uma razão bastante arbitrária para reduzir o voto.
— Dennis
11
@ Dennis Talvez, mas ainda mantenho minha opinião e tenho todo o direito de expressá-la. Eu já vi esse método usado inúmeras vezes nesses tipos de desafios e requer pouca ou nenhuma criatividade da parte do OP, que são grandes aspectos, pelo menos na minha opinião, dos desafios da complexidade de Kolomogorov e, portanto, a minha razão para a baixa votação .
— R. Kap
2
@ R.Kap Se os algoritmos de compressão de uso geral podem superar os manuais com facilidade, isso é um problema do desafio, não a resposta. Eu nem consegui derrotar Bubblegum com Jelly, e a descompressão teve muito pouco impacto em Jelly.
— Dennis
2
@ Dennis Eu nem estou falando sobre o comprimento do código aqui. Estou falando de esforço e criatividade, que essa resposta, na minha opinião, falha em mostrar em um idioma em que se pode fazer muito mais, e foi por essa razão que votei menos. Agora, se você não concorda com o meu raciocínio, tudo bem. Nesse caso, vamos apenas concordar em discordar e encerrar esta conversa aqui antes que ela demore muito. :)
— R. Kap
6

C (gcc) , 187 bytes

Economizou 2 bytes graças a Cody Gray e 3 bytes graças 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"  |/");}

Experimente online!

— musicman523
fonte
2
putsseria trivialmente mais curto, se uma nova linha à direita for aceitável.
— Cody Grey
você pode usar em f()vez de main(). Uma função também é aceitável.
— Keyu Gan
5

Ferrugem , 181 bytes

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

Experimente online!

Ferrugem , 184 bytes

Esta versão pode ser mais fácil de jogar, pois a adição de um replacecusto adicional diminui o número de bytes cada. O primeiro replacenão faz parte do loop, porque gera o dobro do dever mudando spara um ao Stringinvés de 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}

Experimente online!

— CAD97
fonte
5

C, 167 bytes

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

Experimente online!

Nota: muitos espaços aparentes acima são, na verdade, o caractere de tabulação.

Versão legível:

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

Explicação:

A matriz de dados, d, codifica a resposta em caracteres únicos literais e em caracteres repetidos codificados. Cada caractere, c, na matriz de dados é mapeado para um caractere base, b e várias repetições. É então impresso isso várias vezes.

Os caracteres usados ​​apenas isoladamente (barras e o tubo) têm códigos ASCII 47, 92 e 124. Dois deles são divisíveis por 5 com um restante de 2 (c%5=2||c>123) . Não consegui encontrar uma condição mais curta para testar os três.

Os caracteres que são repetidos (sublinhado, traço e espaço), com códigos ASCII 95, 45 e 32, respectivamente, são codificados com um código ASCII mais alto - aumentado em um por repetição. Assim, por exemplo, um único espaço é apenas um espaço, mas dois espaços podem ser codificados pelo próximo caractere ASCII, o ponto de exclamação. Onde um caractere codificado não é adequado porque atende à condição de módulo acima, ele pode ser dividido, como em # & para representar onze espaços. A mesma técnica é usada para evitar sobreposição entre os intervalos de caracteres de espaço e traço.

Finalmente, as dez novas linhas são codificadas como guias para salvar bytes que seriam gastos escapando das novas linhas com uma barra invertida e depois incrementadas para impressão ( ++c).

— jiv
fonte
Bem feito! Eu sabia que havia melhores respostas C por aí.
— musicman523
Obrigado! Foi um desafio divertido. Passei algo como quatro horas nisso, então estou feliz que tenha funcionado no final.
— jiv
4

Carvão , 49 37 bytes

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

Experimente online!

Finalmente eu poderia jogar um pouco isso. Essa resposta (diferente de todas as outras respostas do carvão vegetal) não usa reflexão, mas desenha todo o contorno de uma só vez, deixando as barras horizontais para o final.

Link para a versão detalhada .

— Charlie
fonte
"Diferentemente de todas as outras respostas do carvão vegetal" Na verdade, minha primeira resposta também não usou reflexão, mas admito que não percebi a chance de tirar um byte iniciando o desenho com a linha vertical esquerda. (O único outras mudanças entre as nossas soluções são que você use Faixa onde eu costumava Times e imprimir um \onde eu apenas impresso :UpLeft1 etapa.)
— Neil
Embora pareça o reflexo é até o caminho a percorrer ...
— Neil
Também isso é duas vezes agora que a minha chave s não funcionou ...
— Neil
3

Chiclete , 40 bytes

Economizou 1 byte removendo uma nova linha à direita, obrigado @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...

Experimente online!

— musicman523
fonte
Sem uma nova linha à direita, isso obtém 40 bytes .
— ovs 01/07/19
Obrigado! Acho que meu editor de texto automaticamente colocar um no.
— musicman523
Como você criou isso? zlib.compress(s.encode(), 9)gera 46 bytes, e a resposta parece ser zlib.
— NieDzejkob
Por sugestão de Dennis , eu costumava zopfli --deflategerar o fluxo DEFLATE bruto e depois xxdconvertê-lo no formato xxd. Acredito que zlibdeixa uma soma de verificação ou não é um fluxo DEFLATE bruto por algum outro motivo.
— musicman523
3

Carvão , 38 bytes

←…_χＰ↑⁵Ｐ\Ｆ³«↑Ｐ¹¹↑»↗¹…_χ‖ＢＭ²¦⁷Ｐ↓⁴… ⁴↙↙³

Experimente online!

Usei a resposta de Carlos em sua forma original como ponto de partida, mas economizei bastante usando uma reflexão, aproveitando a simetria horizontal. (A simetria vertical não valeu a pena porque os sublinhados acabaram na linha errada.) Você pode ver a evolução da tela em cada etapa aqui .

Aqui está a versão detalhada .

— DLosc
fonte
btw, você pode usar -dpara mostrar cada etapa (também lamento ter mudado tanto o carvão, não tenho muita certeza de que muitas das novas idéias sejam muito úteis, especialmente a arte de cabra e arte embutida e parte da linguagem wolfram haha)
— somente ASCII
11
— ASCII-only
3

Python 2, 119 117 116 bytes

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

Experimente online!

Um pouco de codificação de execução torturada ...

EDIT: salve 3 bytes substituindo o conjunto de comprimentos:

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

com

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

— Chas Brown
fonte
Uau! Eu estava tentando pensar em uma maneira eficaz de fazer isso sozinho.
— GarethPW
Código legal, mas parece que são 119 bytes?
— Mdahmoune 02/07
@mdahmoune: Muito bem - esqueceu de uso r''ao verificar o comprimento ...
— Chas Brown
3

C ++ 11 - 162 159 154 152 150 bytes

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

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

A sequência de entrada ié codificada em pares de caracteres:

  1. Contagem de caracteres a serem repetidos (adicionado a 'a' para ser um caractere legível)
  2. Char para imprimir

Eu acho que ainda há muito espaço para melhorias aqui.

Editar:

  1. Putchar substituído por cout <<
  2. Remover while, use o construtor de string para repetir caracteres
  3. Removido o espaço antes do ponteiro e um ponto e vírgula espúrio ;;
  4. Instruções de composição com vírgula, remoção de chaves.
— Robert Andrzejuk
fonte
O C ++ 11 não suporta autocomo tipo de retorno, esse é um recurso do C ++ 14. No entanto, você pode corrigir isso e salvar um byte, fazendo o tipo de retorno int. Não parece que esse código funcione; você poderia testá-lo? Experimente online! e veja se você pode consertá-lo?
— musicman523
O tipo de retorno foi alterado automaticamente -> void. Eu estava testando no Visual Studio 2017 - automaticamente C ++ 14. Adicionada uma versão para o gcc.
— Robert Andrzejuk
Oh ok, entendi. Estou executando o Linux e não tenho o VS. Bom trabalho!
— precisa
Oi Robert - sua abordagem de codificação de duração da execução é semelhante à minha; veja aqui . Além disso, empacoto cada par (comprimento, caractere) em um único caractere em vez de 2. Existem 7 caracteres possíveis e 8 comprimentos distintos; então eu uso os 56 caracteres ' '..'X'para codificação; que economiza 40 bytes com um pouco de sobrecarga extra para decodificação.
— Chas Brown
3

Montagem R16K1S60 , 152 144 bytes

Grava a saída na tela periférica do R16K1S60 em ASCII. É executado no The Powder Toy salvar2012356 . (Veja o link no cabeçalho para informações)

O tamanho do byte do programa é o resultado compilado (Células Usadas * 2), não o assembly.

Você sabe que se saiu bem quando o logotipo ocupa mais espaço que o seu 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

Explicação

O código de montagem acima implementa um algoritmo de compactação simples, com as palavras 0x000C como uma nova linha e 0x0009 como o comando para interromper a execução.

As outras palavras são codificadas simplesmente, assim: 0xTTCC

  • T: Vezes para repetir o valor

  • C: O caractere ASCII a ser impresso

O ASM usa todos os registros disponíveis, incluindo alguns dos menos usados:

  • O Ponteiro de Instruções, para que alguns valores conhecidos sejam recuperados rapidamente para salvar alguns bytes (um valor constante em uma instância que não é apenas um registro usa um byte extra para armazená-lo)

  • O ponteiro da pilha é usado como sexto registro de uso geral, porque nenhum código usa a pilha.

Somente AX, BX, CX e DX são realmente usados ​​para dados importantes. EX e SP são usados ​​para armazenar algumas constantes que são usadas com freqüência.

É um tanto simples e sem chance de ganhar, mas foi divertido escrever!

Consulte o histórico de revisões para obter a resposta antiga (é tão grande em termos de ASM)

fato relevante: se isso fosse medido em palavras (no caso dos R16K1S60,16 bits), seria menor que a resposta da pyth, em 72 bytes

— moonheart08
fonte
2

Mathematica, 163 bytes

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

Python 2, 171 bytes

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

Cada linha tem exatamente 85 bytes! Hoorah!

— Daniel
fonte
2

Zsh, 244 bytes

Isso foi escrito especificamente para o Zsh, não o Bash, pois permite um pouco mais em termos de sintaxe estranha.

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 tentei executá-lo no tio.run, a saída é diferente da do meu terminal. A correção para isso está substituindo

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

com

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

o que tornaria 245 bytes ( link ).

Editar Parece que eu estava ansioso demais para apertar o botão de postagem e perdi alguns espaços, tornando minha solução um pouco menos eficiente. Minha nova saída parece desativada, mas acho que contei corretamente (mas não mudaria o tamanho).

— Luca_Scorpion
fonte
Bem-vindo ao PPCG! Observe que a linha inferior de sublinhados possui uma lacuna de quatro espaços, que está faltando na saída do seu código.
— Steadybox 01/07/19
@Steadybox Ohh me bobo. Atualizei a resposta, obrigado por apontar!
— 22475 Luca_Scorpion
Sem problemas! Infelizmente, acho que ainda está um pouco errado, mas isso deve corrigi-lo (e economiza um byte também!).
— Steadybox 01/07/19
Eu acho que você pode salvar alguns bytes usando 'funcname () {}' em vez de 'function funcname {}'
— Winny
2

Python 2, 159 153 139 bytes

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)

Experimente online!

EDIT: salvou 6 bytes usando %formatação em vez de .format().
EDIT: Salva outros 14 bytes corrigindo a saída, graças ao musicman523.

— LyricLy
fonte
11
Isso não está imprimindo o texto exato (linhas extras estão presentes). Corrigir isso provavelmente salvará alguns bytes também.
— officialaimm
Aqui está uma versão fixa , chegando a um hot 139 bytes
— musicman523
2

Japt , 79 72 71 bytes

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

Teste-o

  • 7 bytes economizados graças à excelente sugestão da ETHproductions de usar números inteiros de base 32 para os valores de repetição.
— Shaggy
fonte
Método de compressão muito bom. Se você usar nHvocê pode economizar um pouco mais bytes: ethproductions.github.io/japt/...
— ETHproductions
1

JavaScript (ES6), 151 bytes

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

Snippet de teste

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>
Expandir snippet

— Justin Mariner
fonte
1

Carvão , 48 bytes

↙¹→Ｐ¹¹↓↓¹Ｐ¹¹‖Ｂ↓¦↘→×¹⁰_Ｍ⁷↑←←×¹⁰_‖ＢＪ¹¹¦⁶→×⁴ ↙↙³↑↑³

Experimente online!

Internos um pouco diferentes dos de Carlos, embora não sejam visíveis a princípio.

— Erik, o Outgolfer
fonte
1

,,, , 115 101 98 bytes

Estou absolutamente envergonhado por ser o melhor que posso produzir. >.>

"|/
"' 11×:"| /
"⇆:"|  /
"⇆'
'/'_5×' 4×'_10×92c'
'|' 19×'|'
'-21×+++++3×110⇆⊣"\
"' 19×'/'
'_19×' #
— totalmente humano
fonte
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.