Imprima el favicon de Stack Exchange

19

Desafío

Imprima o devuelva el favicon de Stack Exchange, como se proporciona a continuación:

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

Este es el código de golf , por lo que gana la respuesta más corta en cada idioma.

code-golf  string  ascii-art  kolmogorov-complexity 
— musicman523
fuente
2
¿Se pretende que la esquina superior izquierda esté ligeramente desalineada?
— ETHproductions 01 de
@ETHproductions Se fue la intención, pero estoy cambiando ahora. Parece un poco incómodo de cualquier manera.
— musicman523
2
La salida real es de 219 bytes, para referencia.
— totalmente humano
Se permiten líneas finales y / o espacios finales en las líneas, ¿verdad?
— dzaima 01 de
1
— Taylor Scott

Respuestas:

43

Lenguaje de script Operation Flashpoint , 263 195 bytes

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

No es la herramienta adecuada para el trabajo.

Llamar con:

hint call f;

Salida:

El formato falla, porque la fuente no es monoespaciada.

— Steadybox
fuente
49
Justo lo que hace que nos fijamos en un desafío y piensa "Oh, debería responder que en la Operación Flashpoint" me intriga ...
— totallyhuman
77
@totallyhuman Supongo que su lenguaje de secuencias de comandos es divertido de escribir. Tiene algunas peculiaridades y limitaciones, por lo que a veces es necesario usar algunas soluciones extrañas, lo que lo hace interesante (pero no muy práctico).
— Steadybox 01 de
55
Codificar la respuesta probablemente le dará una mejor puntuación.
— NieDzejkob
2
@NieDzejkob Ahora es más corto que simplemente codificar la salida, pero más aburrido que la versión anterior.
— Steadybox 01 de
@totallyhuman Y con este desafío en particular, quería probar cómo le iría al idioma con un desafío de complejidad de Kolmogorov (para el cual es mucho menos que ideal).
— Steadybox 01 de
11

Carbón , 38 37 33 30 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Editar: gestionado para guardar un byte con la ayuda de una reflexión, aunque @CarlosAlejo muestra que, de hecho, se puede hacer en 37 bytes sin reflejar. Se guardaron otros 4 bytes dibujando el left izquierdo y reflejando el ¼ final. Editar: la respuesta anterior de 33 bytes dependía de ReflectButterflyOverlap()no sobreimprimir el área de superposición con el reflejo, por lo que en caso de que este comportamiento cambiara, busqué una solución que no confiara en eso, y el resultado resultó ser más corto de todos modos, gracias a mi Uso creativo de la impresión de una matriz. Explicación:

←×_χ                            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
fuente
2
Muy bien jugado. ¡Me encanta que haya cuatro respuestas de carbón para esta pregunta! ‖ＢＯno estaba en el idioma la última vez que lo usé, tendré que tenerlo en cuenta para el futuro.
— DLosc
Tenía que ver por mí mismo lo que querías decir con "reflejar el ¼ final". Bien jugado de hecho!
— Charlie
8

/// , 98 bytes

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

Pruébalo en línea! O, ¡ míralo interactivamente!

— Conor O'Brien
fuente
3
¿Hay alguna utilidad que me permita ver los diferentes "pasos" de un programa ///? (Ejecución parcial después de cada reemplazo). Eso podría ayudarme a comprenderlos mejor.
— CAD97
@ CAD97 He estado jugando con el intérprete en línea, y generalmente vendría con opciones de depuración, pero la forma en que el intérprete en línea ordena argumentos, no funciona de esa manera. Puede tomar una copia del intérprete y hacer algo como perl slashes.pl -d1 code.txt. Actualmente estoy trabajando en un entorno de ejecución en línea para ///, pero eso puede llevar algún tiempo.
— Conor O'Brien
3
@ CAD97 Dicho en línea está listo, ¡eche un vistazo!
— Conor O'Brien
8

JavaScript (ES6), 113 112 bytes

(Guardado un byte gracias 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 fragmento

— Rick Hitchcock
fuente
Parece que tiene un espacio perdido antes de la función de reemplazo. Acababa de llegar con una actualización similar para mi solución JS en 113 bytes. No sé si debería publicarlo o dejar que lo tengas.
— Shaggy
Ah, espera, solo viendo ahora que publicaste tu solución antes de que yo publicara la mía. Eliminaré el mío cuando llegue a una computadora y puedas guardar un byte con replace(/.(\d+)/g,(a,b)=>a[0].repeat(b)).
— Shaggy
Gracias Shaggy. Había escrito un programa para automatizar este tipo de respuesta, y era una tontería que generara un espacio innecesario. Su replaceafirmación sugerida es ciertamente una mejora, que ahora he incorporado en mi programa.
— Rick Hitchcock
1
Se puede guardar una matriz de bytes a juego a: ([a],b)=>a.repeat(b))?
— Craig Ayre
¡Si gracias! No estaba familiarizado con esa sintaxis.
— Rick Hitchcock
7

SOGL V0.12 , 32 31 bytes

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

Pruébalo aquí!

Explicación:

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

El cuarto:

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

y la otra parte:

    
|  /
| /
|/
— dzaima
fuente
"togethe"? "canal"? Además, tardó un poco en darse cuenta de lo que .significaba la explicación string. Tal vez usar ^...'y "...'?
— CalculatorFeline
@CalculatorFeline Usualmente lo hice ...para cadenas comprimidas (sin sentido), pero últimamente comencé a hacer una o dos. Y siéntase libre de corregir mis errores y gramática: p
— dzaima
7

Python 2 , 115 bytes, una idea más 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

Pruébalo en línea!

Python 2 , 102 bytes, idea aburrida

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

Pruébalo en línea!

— mdahmoune
fuente
2
Estoy rechazando votar esto porque he visto este método usado demasiadas veces. Es aburrido ver una y otra vez.
— R. Kap
8
@ R.Kap A menos que haya un camino más corto, esa es una razón bastante arbitraria para rechazar.
— Dennis
1
@ Dennis Quizás, pero aún mantengo mi opinión y tengo todo el derecho de expresarla. He visto este método utilizado innumerables veces en este tipo de desafíos y requiere poca o ninguna creatividad por parte del OP, que son aspectos importantes, al menos en mi opinión, de los desafíos de complejidad de Kolomogorov y, por lo tanto, mi razón para el voto negativo .
— R. Kap
2
@ R.Kap Si los algoritmos de compresión de propósito general pueden vencer a los manuales fácilmente, ese es un problema del desafío, no la respuesta. Ni siquiera logré vencer a Bubblegum con Jelly, y la descompresión tenía muy poca sobrecarga en Jelly.
— Dennis
2
@ Dennis Ni siquiera estoy hablando de la longitud del código aquí. Me refiero al esfuerzo y la creatividad, que esta respuesta, en mi opinión, no se puede mostrar en un lenguaje en el que se pueda hacer mucho más, razón por la cual voté en contra. Ahora, si no está de acuerdo con mi razonamiento, está bien. En ese caso, aceptemos no estar de acuerdo y terminar esta conversación aquí antes de que sea demasiado larga. :)
— R. Kap
6

C (gcc) , 187 bytes

¡Ahorré 2 bytes gracias a Cody Gray y 3 bytes gracias 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"  |/");}

Pruébalo en línea!

— musicman523
fuente
2
putssería trivialmente más corto, si una nueva línea final es aceptable.
— Cody Gray
puedes usar en f()lugar de main(). Una función también es aceptable.
— Keyu Gan el
5

Óxido , 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))

Pruébalo en línea!

Óxido , 184 bytes

Esta versión puede ser más golfable ya que agregar más replacecosto menos bytes cada uno. El primero replaceno es parte del ciclo porque hace que el doble servicio cambie a a sen Stringlugar 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}

Pruébalo en línea!

— CAD97
fuente
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);}

Pruébalo en línea!

Nota: muchos espacios aparentes anteriores son en realidad el carácter de tabulación.

Versión legible:

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

Explicación:

La matriz de datos, d, codifica la respuesta en caracteres individuales literales y caracteres repetidos codificados. Cada carácter, c, en la matriz de datos se asigna a un carácter base, b, y varias repeticiones. Luego se imprime muchas veces.

Los caracteres que se usan solo (barras y barras) tienen códigos ASCII 47, 92 y 124. Dos de estos son divisibles por 5 con un resto de 2 (c%5=2||c>123). No pude encontrar una condición más corta para probar los tres.

Los caracteres que se repiten (guión bajo, guión y espacio), con los códigos ASCII 95, 45 y 32 respectivamente, se codifican con un código ASCII más alto, aumentado en uno por repetición. Entonces, por ejemplo, un solo espacio es solo un espacio, pero dos espacios pueden ser codificados por el siguiente carácter ASCII, el signo de exclamación. Cuando un carácter codificado no sería adecuado porque cumple con la condición de módulo anterior, se puede dividir, como con # y para representar once espacios. Se utiliza la misma técnica para evitar la superposición entre el espacio y los rangos de caracteres del guión.

Finalmente, las diez líneas nuevas se codifican como pestañas para guardar bytes que se habrían gastado escapando de las líneas nuevas con una barra diagonal inversa, y luego incrementadas para imprimir ( ++c).

— jiv
fuente
¡Bien hecho! Sabía que había mejores respuestas C por ahí.
— musicman523
¡Gracias! Fue un reto divertido. Pasé unas cuatro horas en él, así que me alegro de que al final funcionó.
— jiv
4

Carbón , 49 37 bytes

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

Pruébalo en línea!

Por fin pude jugar al golf un poco. Esta respuesta (a diferencia de todas las demás respuestas de Carbón) no utiliza la reflexión, sino que dibuja todo el contorno en una pasada, dejando las barras horizontales para el final.

Enlace a la versión detallada .

— Charlie
fuente
"A diferencia de todas las otras respuestas de carbón". En realidad, mi primera respuesta tampoco utilizó la reflexión, pero admito que no descubrí la posibilidad de jugar un byte al comenzar el dibujo con la línea vertical izquierda. (Los únicos otros cambios entre nuestras soluciones son que usas Range donde usé Times e imprimes un \donde acabo de imprimir :UpLeft1 paso.)
— Neil
Aunque parece que el reflejo es el camino a seguir ...
— Neil
También eso es dos veces ahora que mi clave s no funcionó ...
— Neil
3

Chicle , 40 bytes

Salvó 1 byte al eliminar una nueva línea final, ¡gracias @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...

Pruébalo en línea!

— musicman523
fuente
Sin una nueva línea final, esto obtiene 40 bytes .
— ovs 01 de
¡Gracias! Creo que mi editor de texto automáticamente puso uno.
— musicman523
¿Cómo creaste esto? zlib.compress(s.encode(), 9)genera 46 bytes, y la respuesta parece ser zlib.
— NieDzejkob
Según la sugerencia de Dennis , solía zopfli --deflategenerar el flujo DEFLATE sin procesar, luego xxdlo convertía al formato xxd. Creo que zlibdeja una suma de verificación, o no es un flujo DEFLATE sin procesar por alguna otra razón.
— musicman523
3

Carbón , 38 bytes

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

Pruébalo en línea!

Solía respuesta de Carlos en su forma original como punto de partida, sino que guardó a una buena parte mediante el uso de una reflexión, aprovechando la simetría horizontal. (La simetría vertical no valió la pena porque los guiones bajos terminaron en la fila incorrecta). Puede ver la evolución del lienzo en cada paso aquí .

Aquí está la versión detallada .

— DLosc
fuente
por cierto, puede usar -dpara mostrar cada paso (también lo siento, he estado cambiando tanto el carbón, no estoy seguro de que muchas de las nuevas ideas sean muy útiles, especialmente el arte ascii-art de cabra y parte del lenguaje wolfram jaja)
— Solo ASCII
1
— solo ASCII
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')

Pruébalo en línea!

Un poco de codificación de longitud de ejecución torturada ...

EDITAR: Ahorre 3 bytes reemplazando el conjunto de longitudes:

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

con

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

— Chas Brown
fuente
¡Guauu! Estaba tratando de pensar en una forma efectiva de hacerlo yo mismo.
— GarethPW
Buen código, pero parece que es 119 bytes?
— mdahmoune
@mdahmoune: Muy bien - olvidé usarlo r''al verificar la longitud ...
— 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++;}

CCG: (+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;}}

La cadena de entrada ise codifica en pares de caracteres:

  1. Conteo de caracteres para repetir (agregado a 'a' para ser un personaje legible)
  2. Char para imprimir

Creo que todavía hay mucho margen de mejora aquí.

Editar:

  1. Reemplazado putchar con cout <<
  2. Eliminar while, usar el constructor de cadenas para repetir caracteres
  3. Se eliminó el espacio antes del puntero y un punto y coma espurio;
  4. Instrucciones compuestas con comas, eliminando llaves.
— Robert Andrzejuk
fuente
C ++ 11 no es compatible autocomo un tipo de retorno, esa es una característica de C ++ 14. Sin embargo, puede arreglar esto y guardar un byte haciendo el tipo de retorno int. Sin embargo, no parece que este código funcione; ¿podrías probarlo en Probar en línea! y ver si puedes arreglarlo?
— musicman523
Cambió el tipo de retorno auto -> void. Estaba probando en Visual Studio 2017, automáticamente C ++ 14. Se agregó una versión para gcc.
— Robert Andrzejuk
Oh está bien, te tengo. Estoy ejecutando Linux, así que no tengo VS. ¡Buen trabajo!
— musicman523
Hola Robert: tu enfoque de codificación de longitud de ejecución es similar al mío; ver aquí . Además, empaco cada par (length, char) en un único char en lugar de 2. Hay 7 caracteres posibles y 8 longitudes distintas; entonces uso los 56 caracteres ' '..'X'para codificar; que ahorra 40 bytes con un poco de sobrecarga adicional para la decodificación.
— Chas Brown
3

Asamblea R16K1S60 , 152 144 Bytes

Escribe la salida a la pantalla del periférico R16K1S60 en ASCII. Se ejecuta en The Powder Toy save 2012356. (Ver enlace en el encabezado para obtener información)

El tamaño del byte del programa es el resultado compilado (Celdas utilizadas * 2), no el ensamblado.

Sabes que lo has hecho bien cuando el logotipo ocupa más espacio que tu código de bytes.

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

Explicación

El código de ensamblaje anterior implementa un algoritmo de compresión simple, con las palabras 0x000C como una nueva línea y 0x0009 como el comando para detener la ejecución.

Las otras palabras se codifican simplemente, así: 0xTTCC

  • T: tiempos para repetir el valor

  • C: el carácter ASCII para imprimir

El ASM utiliza todos los registros disponibles, incluidos algunos de los menos utilizados:

  • El puntero de instrucciones, para obtener algunos valores conocidos en la recuperación rápida para guardar algunos bytes (un valor constante en una instrucción que no es solo un registro utiliza un byte adicional para almacenarlo)

  • El puntero de pila se usa como sexto registro de propósito general, porque ninguno de los códigos usa la pila.

Solo AX, BX, CX y DX se usan realmente para datos importantes. EX y SP se usan para almacenar algunas constantes que se usan con frecuencia.

Es algo simple y tiene pocas posibilidades de ganar, ¡pero fue divertido escribir!

Vea el historial de revisiones para la respuesta anterior (es tan grande en términos de ASM)

funfact: si esto se midiera en palabras (en el caso de R16K1S60,16 bits) sería más pequeño que la respuesta pyth, a 72 bytes

— moonheart08
fuente
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
fuente
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 línea tiene exactamente 85 bytes! Hoorah!

— Daniel
fuente
2

Zsh, 244 bytes

Esto está escrito específicamente para Zsh, no Bash, ya que permite un poco más en términos de sintaxis extraña.

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: cuando intenté ejecutarlo en tio.run, la salida es diferente a la de mi terminal. La solución a esto es reemplazar

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

con

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

lo que lo convertiría en 245 bytes ( enlace ).

Editar Parece que estaba demasiado ansioso por presionar ese botón de publicación y perdí algunos espacios, lo que hace que mi solución sea un poco menos eficiente. Sin embargo, mi nuevo resultado parece apagado, pero creo que conté correctamente (pero de todos modos no cambiaría la longitud).

— Luca_Scorpion
fuente
Bienvenido a PPCG! Observe que la línea inferior de guiones bajos tiene un espacio de cuatro espacios, que falta en la salida de su código.
— Steadybox 01 de
@ Steadybox Ohh, tonto de mí. He actualizado la respuesta, ¡gracias por señalarlo!
— Luca_Scorpion 01 de
¡No hay problema! Desafortunadamente, creo que todavía está un poco apagado, pero esto debería solucionarlo (¡y también te ahorra un byte!).
— Steadybox 01 de
Creo que puede guardar algunos bytes utilizando 'funcname () {}' en lugar de 'function funcname {}'
— Winny el
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)

Pruébalo en línea!

EDITAR: guardado 6 bytes mediante el %formato en lugar de .format().
EDITAR: ahorró otros 14 bytes arreglando la salida, gracias a musicman523.

— LyricLy
fuente
1
Esto no imprime el texto exacto (hay líneas adicionales). Arreglar esto probablemente también ahorrará algunos bytes.
— officialaimm
Aquí hay una versión fija , llegando a 139 bytes calientes
— musicman523
2

Japt , 79 72 71 bytes

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

Pruébalo

  • 7 bytes guardados gracias a la excelente sugerencia de ETHproductions de usar enteros de base 32 para los valores de repetición.
— Lanudo
fuente
Muy buen método de compresión. Si lo usa nH, puede guardar algunos bytes más: 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]))

Fragmento de prueba

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 fragmento

— Justin Mariner
fuente
1

Carbón , 48 bytes

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

Pruébalo en línea!

Partes internas algo diferentes a las de Carlos, aunque no visibles al principio.

— Erik el Outgolfer
fuente
1

,,, , 115 101 98 bytes

Estoy absolutamente avergonzado de que esto sea lo mejor que puedo producir. >.>

"|/
"' 11×:"| /
"⇆:"|  /
"⇆'
'/'_5×' 4×'_10×92c'
'|' 19×'|'
'-21×+++++3×110⇆⊣"\
"' 19×'/'
'_19×' #
— totalmente humano
fuente
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.