El 5 de abril es el Día Nacional de Pizza Deep DIsh, el tema de este desafío. Dado un número entero positivo n( nes mayor que 0), cree una pizza de plato hondo ASCII. Pizza de plato hondo real que se muestra:

Como puede ver, hay una capa de corteza en el fondo y que rodea el resto de la pizza.

Como hacer la pizza

La corteza está hecha de dos capas. La primera capa será nalta y n*3larga. La longitud es el número de caracteres (incluidos los espacios) en la línea más alta. Entonces dado nes 1, la primera capa se vería así:

\_/  1 character tall
 3 characters long

Si nson dos:

\    /   2 characters tall
 \__/
  6 characters long

Ahora para la segunda capa de la corteza. Saldrá fuera de la primera corteza interna, por lo tanto, serán n+2caracteres altos y (n*3)+6)caracteres largos. Dado nes uno:

\       /  3 characters tall
 \     /
  \___/
   9 characters long (3 underscores, 3 slashes on either side)

Si nson dos:

\          / 4 characters high
 \        /
  \      /
   \____/
    12 characters long

Luego emparejarías los dos pares más altos \/entre sí para la corteza interna y externa. En nes 1:

\ \   / /
 \ \_/ /
  \___/

Si se hace correctamente, se vería como una V sin la parte superior con una diferencia de un carácter entre cada capa. Hablando de tapas, la corteza se unirá por un par de /\, separadas por una línea de guiones bajos (n*3)+2para completar la corteza y la pizza.

Ejemplos

Si nes 1:

/\_____/\
\ \   / /
 \ \_/ /
  \___/

n es 2:

/\________/\
\ \      / /
 \ \    / /
  \ \__/ /
   \____/ 

n es 3:

/\___________/\
\ \         / /
 \ \       / /
  \ \     / /
   \ \___/ /
    \_____/

Criterio ganador

Este es el código de golf , por lo que gana el código más corto en bytes.

Carbón , 35 bytes

Ｎθ←_←×_θ↖θ↖²Ｍ→/Ｐ×_⁺²×²θ↘θ↘¹\×_θ‖ＢＯθ

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

Ｎθ

Ingrese el tamaño de la pizza.

←_←×_θ

Imprima parte de la base de la corteza exterior.

↖θ↖²

Imprima la corteza exterior del lado izquierdo.

Ｍ→/Ｐ×_⁺²×²θ

Imprima parte de la corteza superior.

↘θ↘¹\

Imprima la corteza interna del lado izquierdo.

×_θ

Imprima parte de la base interna de la corteza.

‖ＢＯθ

Reflexiona para completar la pizza.

Tenga en cuenta que las adiciones modernas al carbón reducen el tamaño a 31 bytes:

Ｎθ←×_⊕θ↖θ↖²Ｍ→/Ｐ×_⊗⊕θ↘⊕θ\×_θ‖ＢＯθ

Pruébalo en línea! El enlace es a la versión detallada del código.

JavaScript (ES6), 136 bytes

f=
n=>"/\\"+(r=s=>s[0][0].repeat(n-1)+s)`_`+r`_`+r`___/\\
`+r` `.replace(/ /g,"$`\\ \\$`   $'$'$'/ /\n")+r` \\ \\`+r`_/ /
`+r`  \\`+r`___/`

<input type=number min=1 oninput=o.textContent=f(this.value)><pre id=o>

Toda la pizza es muy repetitiva, por lo que la rfunción (diseñada como un literal de plantilla etiquetado) repite el primer carácter de sus ntiempos de entrada . Esto maneja las dos líneas superiores e inferiores de la pizza. El medio se repite reemplazando una cadena de espacios en blanco; las subvenciones $`y $'corresponden automáticamente a un número creciente y decreciente de espacios en blanco, lo que coloca el \ \y / /apropiadamente.

Python 2, 153151 bytes

Pruébalo en línea

n=input()
a=' '*n
b='_'*n
print'/\\__'+b*3+'/\\'
i=0
exec"print' '*i+'\ \\\\'+' '*(3*n-2*i)+'/ /';i+=1;"*n
print a+'\ \\'+b+'/ /'
print a+' \\_'+b+'_/'

-2 bytes sustituyendo valores repetidos con variables gracias a @KoishoreRoy

MATLAB, 333 bytes

(Intento de pereza)

function t(n);p=@(q)fprintf(q);s=@(x)p(' ');r=@()p('/ /');l=@()p('\\ \\');f=@()p('/');b=@()p('\\');u=@(x)p('_');h=@()p('/\\');e=@()p('\n');h();arrayfun(u,1:3*n+2);h();e();for i=1:n;arrayfun(s,1:i-1);l();arrayfun(s,1:3*n-2*(i-1));r();e();end;arrayfun(s,1:n);l();arrayfun(u,1:n);r();e();arrayfun(s,1:n+1);b();arrayfun(u,1:n+2);f();e();

Formateado:

function d(n)
p=@(q)fprintf(q);
s=@(x)p(' ');
r=@()p('/ /');
l=@()p('\\ \\');
f=@()p('/');
b=@()p('\\');
u=@(x)p('_');
h=@()p('/\\');
e=@()p('\n');
h();arrayfun(u,1:3*n+2);h();e();
for i=1:n
arrayfun(s,1:i-1); l(); arrayfun(s,1:3*n-2*(i-1)); r();e();
end
arrayfun(s,1:n); l(); arrayfun(u,1:n); r();e();
arrayfun(s,1:n+1); b(); arrayfun(u,1:n+2); f();e();

La idea básica es que tengo manejadores de funciones para imprimir todo, y luego simplemente lo fuerza por fuerza bruta. El bucle for es para las ncapas entre la parte superior e inferior de la capa interior. La repetición de (espacios) y _se hace usando arrayfun, con entradas de matriz. Intentaré pensar en formas más interesantes de hacer esto si tengo más tiempo más tarde.

Carbón , 54 52 bytes

Ａ⁺Ｎ²β↖Ｍ↓↙¹Ｍ→↘βＭ↑×_β↗βＭ←↖¹Ｍ↓↙βＭ↑←×_⁺β±²↖βＭ↘Ｍ→×_⁺×β³±⁴

Explicación:

Ａ⁺Ｎ²β       Assign input + 2 to the variable β
↖             Move up and left one, printing a \
Ｍ↓           Move pointer down one
↙¹            Move down and left one, printing a /
Ｍ→           Move pointer right one
↘β            Move down and right β times
Ｍ↑           Move pointer up
×_β           Write underscores β times
↗β            Move up and right β times
Ｍ←           Move pointer right one
↖¹           Move up and left one
Ｍ↓           Move pointer down one
↙β           Move down and right β times
Ｍ↑           Move up one
←             Set direction to left
×_⁺β±²        Write underscores β - 2 times
↖β            Move up and left β times
Ｍ↘           Move down and right one
Ｍ→           Move right one
×_⁺×β³±⁴      Write underscores (β * 3) - 4 times

Mi respuesta anterior fue en Retina, un idioma al que no había publicado una respuesta antes. Ahora, tienes una respuesta en Charcoal, a la que no he publicado una respuesta antes.

Pruébalo en línea!

PHP, 209 200 137 135 bytes

finalmente venciendo a JS :)

echo($f=str_pad)("/\\",1+3*$x=$n=1+$argn,_),"/\\
";for(;$n;)echo$f("\\ \\",2*$n+$x," _"[!--$n]),"/ /
",$p.=" ";echo$f("\\",2+$x,_),"/";

Toma entrada de STDIN; correr -nRo pedir una pizza familiar .

Descompostura

// print top
echo($f=str_pad)("/\\",1+3*$x=$n=1+$argn,_),"/\\\n";
// loop N+1 times
for(;$n;)
    // print current line and left padding for next line
    echo$f("\\ \\",2*$n+$x," _"[!--$n]),"/ /\n",$p.=" ";
// print bottom
echo$f("\\",2+$x,_),"/";

JavaScript (ES6), 205 bytes

¡Esta es mi primera publicación de arte ascii !

Agregue un f=al principio e invoque como f(arg).

n=>{a=[];w=" ";u="_";t=`/\\${u.repeat(n*3+2)}/\\
`;for(i=0;i<n+1;i++){c=i==n?u:w;a.push(`${w.repeat(i)}\\ \\${c.repeat((n+1-i*2)+n+(n-1))}/ /
`)};return [t,...a,`${w.repeat(i)}\\${u.repeat(n+2)}/`].join``}

Nota: ¡ Todos los saltos de línea son necesarios!

f=n=>{a=[];w=" ";u="_";t=`/\\${u.repeat(n*3+2)}/\\
`;for(i=0;i<n+1;i++){c=i==n?u:w;a.push(`${w.repeat(i)}\\ \\${c.repeat((n+1-i*2)+n+(n-1))}/ /
`)};return [t,...a,`${w.repeat(i)}\\${u.repeat(n+2)}/`].join``}

document.querySelector("#elem").innerHTML = f(+prompt("Enter a Number"));

<pre id="elem">

Explicación

El código primero declara una matriz a. Luego declara wy utiene el valor de espacios en blanco y subrayado respectivamente. Luego, declara una variable de cadena para contener el valor de la corteza (que se puede calcular /\+(n*3+2 underscores)+/\, como se menciona en el desafío). Después de eso, con un forbucle y a Template Literal, se crea la mitad de la pizza (cada capa tiene iespacios en blanco al inicio y (n+1-i*2)+n+(n-1)espacios en blanco entre \ \y / /, donde irepresenta el índice del forbucle). Por último, se crea la parte inferior de la pizza ( (i whitespaces)+\+(n+2 underscores)+/). Todas las partes se unen y salen (ted).

Si por alguna razón el fragmento no muestra el arte ASCII correctamente, eche un vistazo aquí .

¡Feliz día de Deep Dish Pizza para todos!

Lote, 200 bytes

@set l=@for /l %%i in (1,1,%1)do @call 
@set t=
@set s=
%l%set s=___%%s%%
@echo /\_%s%_/\
%l%echo %%t%%\ \%%s:_= %%/ /&call set t= %%t%%&call set s=%%s:~2%%
@echo %t%\ \%s%/ /
@echo %t% \_%s%_/

tcontiene la sangría izquierda mientras scontiene el interior; sus _s están sustituidos con espacios en las filas del medio. lsimplemente existe para evitar alguna repetición.

V , 57 bytes

i\ \´ / /ÙãxX2r_>>Ù>>lxxE2r_À­ñHãyêP>GÄXã2é ñHÄÒ_R/\$h.

Pruébalo en línea!

Como (como de costumbre) contiene muchos caracteres desagradables que no son ASCII y no se pueden imprimir, aquí hay un hexdump:

00000000: 695c 205c b420 2f20 2f1b d9e3 7858 3272  i\ \. / /...xX2r
00000010: 5f3e 3ed9 3e3e 6c78 7845 3272 5fc0 adf1  _>>.>>lxxE2r_...
00000020: 48e3 79ea 503e 47c4 58e3 32e9 20f1 48c4  H.y.P>G.X.2. .H.
00000030: d25f 522f 5c1b 2468 2e                   ._R/\.$h.

Publicaré una explicación más detallada pronto, pero aquí hay una descripción general de alto nivel:

i\ \´ / /ÙãxX2r_>>Ù>>lxxE2r_
"Create 
"\ \    / /
" \ \__/ /
"  \____/
"This can probably be compressed a lot more

À­ñHãyêP>GÄXã2é ñ
"*arg1 times*, expand the pizza slice

HÄÒ_R/\$h.
"Add the crust

C (clang) , 211 215 bytes

i,l;f(n){l=n*3+6;char u[l];for(i=0;i<l;)u[i++]='_';u[l-1]=i=0;printf("/\\%.*s/\\\n",l-4,u);for(;i<n;i++)printf("%*s\\ \\%*.s/ /\n",i,"",n*3-(2*i),"");printf("%*.s\\ \\%.*s/ /\n%*.s\\%.*s/\n",i,"",n,u,i+1,"",n+2,u);}

Pruébalo en línea!

Pretty Code:

i,l;
f(n) {
    l = n*3+6;
    char u[l];

    // Initialize u[] with a full line of underscores,
    for (i=0;i<l;)
        u[i++] = '_';

    // Make sure the string ends in a valid way
    u[l] = i = 0;

    /* Print the crust 'top'
     * l-4 dashes are needed because '/\/\'
     * %.*s notation to pad (l-4) bytes of the underscore string
     */
    printf("/\\%.*s/\\\n", l-4,u);

    /* Print n rows of just 'walls' \ \  / /
     * each row has i=0++ leading spaces,
     * and each row has n*3-(2i) center spaces
     */
    for(; i<n; i++)
        printf("%*s\\ \\%*.s/ /\n", i,"", n*3-(2*i), "");

    /* Print i spaces, '\ \', n underlines, '/ /'
     * then i+1 spaces, '\', n+2 underlines, and '/'
     */
    printf("%*.s\\ \\%.*s/ /\n%*.s\\%.*s/\n",i,"",n,u,i+1,"",n+2,u);
}

Ediciones:

• eliminado s [l] y asociado al cambiar de%. s notación a% .s
• función adicional para el cumplimiento y pruébelo en línea

CJam, 74 bytes

Manera demasiado tiempo. Voy a intentar otro enfoque.

"/\\"ri:M3*:A2+'_*1$NL{"\ \\"AS*"/ /"3$S+A((:A;N\}M*4$A'_*4$N4$S'\A2+'_*'/

Construye la cadena línea por línea. Nada muy loco

CJam, 89 bytes

Bueno, en realidad es más larga que mi otra solución en este momento, pero creo que es más fácil de jugar:

ri{:T)_S*a*ee_{~'\t}%TS*aTU+*'_f+@{~'/t}%W%++z}:K~2S*f{\+}T1:U+K..e>"/\\"'_T3*(*1$++a\+N*

Seguimiento de pila:

"2" ; r
2 ; i
2 {:T)_S*a*ee_{~'\t}%TS*aTU+*'_f+@{~'/t}%W%++z} ; {}
2 {:T)_S*a*ee_{~'\t}%TS*aTU+*'_f+@{~'/t}%W%++z} ; :K
2 ; ~
2 ; :T
3 ; )
3 3 ; _
3 3 " " ; S
3 "   " ; *
3 ["   "] ; a
["   " "   " "   "] *
[[0 "   "] [1 "   "] [2 "   "]] ; ee
[[0 "   "] [1 "   "] [2 "   "]] [[0 "   "] [1 "   "] [2 "   "]] ; _
[[0 "   "] [1 "   "] [2 "   "]] ["\  " " \ " "  \\"] ; {~'\t}%
[[0 "   "] [1 "   "] [2 "   "]] ["\  " " \ " "  \\"] 2 ; T
[[0 "   "] [1 "   "] [2 "   "]] ["\  " " \ " "  \\"] 2 " " ; S
[[0 "   "] [1 "   "] [2 "   "]] ["\  " " \ " "  \\"] "  " ; *
[[0 "   "] [1 "   "] [2 "   "]] ["\  " " \ " "  \\"] ["  "] ; a
[[0 "   "] [1 "   "] [2 "   "]] ["\  " " \ " "  \\"] ["  "] 2 ; T
[[0 "   "] [1 "   "] [2 "   "]] ["\  " " \ " "  \\"] ["  "] 2 0 ; U
[[0 "   "] [1 "   "] [2 "   "]] ["\  " " \ " "  \\"] ["  "] 2 ; +
[[0 "   "] [1 "   "] [2 "   "]] ["\  " " \ " "  \\"] ["  " "  "] ; *
[[0 "   "] [1 "   "] [2 "   "]] ["\  " " \ " "  \\"] ["  " "  "] '_ ; '_
[[0 "   "] [1 "   "] [2 "   "]] ["\  " " \ " "  \\"] ["  _" "  _"] ; f+
["\  " " \ " "  \\"] ["  _" "  _"] [[0 "   "] [1 "   "] [2 "   "]] ; @
["\  " " \ " "  \\"] ["  _" "  _"] ["/  " " / " "  /"] ; {~'/t}%
["\  " " \ " "  \\"] ["  _" "  _"] ["  /" " / " "/  "] ; W%
["\  " " \ " "  \\" "  _" "  _" "  /" " / " "/  "] ; ++
["\      /" " \    / " "  \__/  "] ; z
["\      /" " \    / " "  \__/  "] "  " ; 2S*
["  \      /" "   \    / " "    \__/  "] ; f{\+}
["  \      /" "   \    / " "    \__/  "] 2 ; T
["  \      /" "   \    / " "    \__/  "] 2 1 ; 1
["  \      /" "   \    / " "    \__/  "] 2 1 ; :U
["  \      /" "   \    / " "    \__/  "] 3 ; +
["  \      /" "   \    / " "    \__/  "] ["\          /" " \        / " "  \      /  " "   \____/   "] ; K
["\ \      / /" " \ \    / / " "  \ \__/ /  " "   \____/   "] ; ..e>
["\ \      / /" " \ \    / / " "  \ \__/ /  " "   \____/   "] "/\\" ; "/\\"
["\ \      / /" " \ \    / / " "  \ \__/ /  " "   \____/   "] "/\\" '_ ; '_
["\ \      / /" " \ \    / / " "  \ \__/ /  " "   \____/   "] "/\\" '_ 3 ; T
["\ \      / /" " \ \    / / " "  \ \__/ /  " "   \____/   "] "/\\" '_ 9 ; 3*
["\ \      / /" " \ \    / / " "  \ \__/ /  " "   \____/   "] "/\\" '_ 8 ; (
["\ \      / /" " \ \    / / " "  \ \__/ /  " "   \____/   "] "/\\" "________" ; *
["\ \      / /" " \ \    / / " "  \ \__/ /  " "   \____/   "] "/\\" "________" "/\\" ; 1$
["\ \      / /" " \ \    / / " "  \ \__/ /  " "   \____/   "] "/\________/\\" ; ++
["\ \      / /" " \ \    / / " "  \ \__/ /  " "   \____/   "] ["/\________/\\"] ; a
["/\________/\\" "\ \      / /" " \ \    / / " "  \ \__/ /  " "   \____/   "] ; \+
"/\________/\
\ \      / /
 \ \    / / 
  \ \__/ /  
   \____/   " ; N*
; [implicit output]