Le 5 avril est la Journée nationale de la pizza Deep DIsh, le thème de ce défi. Étant donné un entier positif n( nsupérieur à 0), créez une pizza à plat profond ASCII. Pizza à plat profonde réelle montrée:

Comme vous pouvez le voir, il y a une couche de croûte au fond et entourant le reste de la pizza.

Comment faire la pizza

La croûte est composée de deux couches. La première couche sera nhaute et n*3longue. La longueur est le nombre de caractères (espaces compris) dans la ligne la plus haute. Donc, étant donné n1, la première couche ressemblerait à ceci:

\_/  1 character tall
 3 characters long

Si nest deux:

\    /   2 characters tall
 \__/
  6 characters long

Passons maintenant à la deuxième couche de la croûte. Il ira à l' extérieur de la première, la croûte intérieure ainsi donc, ce sera des n+2caractères grands et (n*3)+6)caractères. Étant donné nest un:

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

Si nest deux:

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

Vous devez ensuite faire correspondre les deux paires les plus élevées \/entre elles pour la croûte intérieure et extérieure. En nest 1:

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

Si cela est fait correctement, il ressemblerait à un V sans les sommets avec une différence d'un caractère entre chaque couche. En parlant de dessus, la croûte sera réunie par une paire de /\, séparés par une ligne de soulignements (n*3)+2longs pour compléter la croûte et la pizza.

Exemples

Si nest 1:

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

n est 2:

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

n est 3:

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

Critère gagnant

Il s'agit de code-golf , donc le code le plus court en octets gagne!

Fusain , 35 octets

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:

Ｎθ

Saisissez la taille de la pizza.

←_←×_θ

Imprimer une partie de la base extérieure de la croûte.

↖θ↖²

Imprimez le côté gauche de la croûte extérieure.

Ｍ→/Ｐ×_⁺²×²θ

Imprimer une partie de la croûte supérieure.

↘θ↘¹\

Imprimez le côté gauche de la croûte intérieure.

×_θ

Imprimer une partie de la base intérieure de la croûte.

‖ＢＯθ

Réfléchissez pour terminer la pizza.

Notez que les ajouts modernes au charbon de bois réduisent la taille à 31 octets:

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

Essayez-le en ligne! Le lien est vers la version détaillée du code.

JavaScript (ES6), 136 octets

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>

La pizza entière est très répétitive, de sorte que la rfonction (conçue comme un modèle littéral étiqueté) répète le premier caractère de ses ntemps d' entrée . Cela gère les deux lignes supérieure et inférieure de la pizza. Le milieu est répété en remplaçant une chaîne de blancs; les $`et les $'substitutions correspondent automatiquement à un nombre croissant et décroissant de blancs positionnant ainsi le \ \et de / /manière appropriée.

Python 2, 153 151 octets

Essayez-le en ligne

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 octets en remplaçant les valeurs répétées par des variables grâce à @KoishoreRoy

MATLAB, 333 octets

(Tentative paresseuse)

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

Formaté:

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

L'idée de base est que j'ai des poignées de fonction pour tout imprimer, puis je le force à peu près brutalement. Celui pour la boucle est pour les ncouches entre le haut et le bas de la couche intérieure. La répétition de (espaces) et _se fait à l'aide arrayfun, avec des entrées de tableau. J'essaierai de penser à des façons plus intéressantes de le faire si j'ai plus de temps plus tard.

Fusain , 54 52 octets

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

Explication:

Ａ⁺Ｎ²β       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

Ma réponse précédente était en rétine, une langue à laquelle je n'ai pas encore répondu. Maintenant, vous avez une réponse dans Charcoal, à laquelle je n'ai pas posté de réponse auparavant.

Essayez-le en ligne!

PHP, 209 200 137 135 octets

enfin battre JS :)

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

Prend l'entrée de STDIN; courir avec -nRou commander une pizza familiale .

panne

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

Ceci est mon premier article ascii-art !

Ajoutez un f=au début et invoquez like 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``}

Remarque: tous les sauts de ligne sont nécessaires!

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

Explication

Le code déclare d'abord un tableau a. Il déclare ensuite wet uayant respectivement la valeur des espaces et des traits de soulignement. Ensuite, il déclare une variable String pour contenir la valeur de la croûte (qui peut être calculée par /\+(n*3+2 underscores)+/\, comme mentionné dans le défi). Après cela, avec une forboucle et un Template Literal, le milieu de la pizza est créé (avec chaque couche ayant des iespaces au début et des (n+1-i*2)+n+(n-1)espaces entre \ \et / /, où ireprésente l'indice de forboucle). Enfin, la partie la plus basse de la pizza est créée ( (i whitespaces)+\+(n+2 underscores)+/). Toutes les pièces sont assemblées et sorties (ted).

Si, pour une raison quelconque, l'extrait n'affiche pas correctement l'illustration ASCII, jetez un œil ici .

Bonne journée de pizza profonde à tous!

Lot, 200 octets

@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%_/

tcontient le retrait gauche tandis que scontient l'intérieur; ses _s sont remplacés par des espaces sur les rangées du milieu. lexiste juste pour éviter une répétition.

V , 57 octets

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

Essayez-le en ligne!

Puisque, (comme d'habitude) cela contient beaucoup de méchants caractères non ASCII et non imprimables, voici 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.

Je publierai bientôt une explication plus détaillée, mais voici un aperçu de haut niveau:

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 octets

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

Essayez-le en ligne!

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

Modifications:

• supprimé s [l] et associé en passant de%. notation s en% .s
• wrapper de fonction ajouté pour la conformité et l'essayer en ligne

CJam, 74 octets

Way trop longtemps. Je vais essayer une autre approche.

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

Génère la chaîne ligne par ligne. Rien de trop fou.

CJam, 89 octets

Eh bien, c'est en fait plus long que mon autre solution pour le moment, mais je pense que c'est plus jouable au golf:

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

Trace de la pile:

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