Der 5. April ist der National Deep DIsh Pizza Day, das Thema dieser Herausforderung. Erstellen Sie bei einer positiven Ganzzahl n( ngrößer als 0) eine ASCII-Deep-Dish-Pizza. Tatsächliche Deep Dish Pizza gezeigt:

Wie Sie sehen können, befindet sich eine Krustenschicht auf dem Boden und umgibt den Rest der Pizza.

Wie man die Pizza macht

Die Kruste besteht aus zwei Schichten. Die erste Schicht wird ngroß und n*3lang sein. Die Länge ist die Anzahl der Zeichen (einschließlich Leerzeichen) in der höchsten Zeile. Wenn nalso 1 angegeben ist, würde die erste Schicht folgendermaßen aussehen:

\_/  1 character tall
 3 characters long

Wenn nzwei sind:

\    /   2 characters tall
 \__/
  6 characters long

Nun zur zweiten Schicht der Kruste. Es wird außerhalb der ersten inneren Kruste gehen, daher wird es n+2Zeichen groß und (n*3)+6)Zeichen lang sein. Gegeben nist eins:

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

Wenn nzwei sind:

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

Sie würden dann die beiden höchsten Paare \/für die innere und äußere Kruste miteinander abgleichen. In nist 1:

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

Wenn es richtig gemacht wird, sieht es aus wie ein V ohne die Oberseiten mit einem Unterschied von einem Zeichen zwischen den einzelnen Ebenen. Apropos Spitzen: Die Kruste wird durch ein Paar zusammengefügt /\, die durch eine Reihe von Unterstrichen getrennt sind (n*3)+2, um die Kruste und die Pizza zu vervollständigen.

Beispiele

Wenn nist 1:

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

n ist 2:

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

n ist 3:

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

Gewinnkriterium

Dies ist Code-Golf , also gewinnt der kürzeste Code in Bytes!

Holzkohle , 35 Bytes

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

Probieren Sie es online aus! Der Link führt zur ausführlichen Version des Codes. Erläuterung:

Ｎθ

Geben Sie die Größe der Pizza ein.

←_←×_θ

Drucken Sie einen Teil der äußeren Krustenbasis.

↖θ↖²

Drucken Sie die äußere Kruste links.

Ｍ→/Ｐ×_⁺²×²θ

Drucken Sie einen Teil der oberen Kruste.

↘θ↘¹\

Drucken Sie die innere Kruste links.

×_θ

Drucken Sie einen Teil der inneren Krustenbasis.

‖ＢＯθ

Überlegen Sie, um die Pizza zu vervollständigen.

Beachten Sie, dass moderne Ergänzungen zu Charcoal die Größe auf 31 Byte reduzieren:

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

Probieren Sie es online aus! Der Link führt zur ausführlichen Version des Codes.

JavaScript (ES6), 136 Byte

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>

Die gesamte Pizza wiederholt sich sehr oft, sodass die rFunktion (als markiertes Vorlagenliteral konzipiert) das erste Zeichen ihrer Eingabezeiten wiederholt n. Dies behandelt die oberen und unteren beiden Zeilen der Pizza. Die Mitte wird wiederholt, indem eine Reihe von Leerzeichen ersetzt wird. Die $`und $'Unterteilungen entsprechen automatisch einer zunehmenden und abnehmenden Anzahl von Leerzeichen, wodurch die \ \und / /entsprechend positioniert werden.

Python 2, 153 151 Bytes

Probieren Sie es online aus

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 durch Ersetzen wiederholter Werte durch Variablen dank @KoishoreRoy

MATLAB, 333 Bytes

(Fauler Versuch)

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

Formatiert:

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

Die Grundidee ist, dass ich Funktionsgriffe habe, um alles zu drucken, und es dann ziemlich brutal erzwinge. Die for-Schleife gilt für die nEbenen zwischen der obersten und der untersten Ebene der inneren Ebene. Die Wiederholung von (Leerzeichen) und _erfolgt arrayfunmit Array-Eingaben. Ich werde versuchen, mir interessantere Möglichkeiten dafür auszudenken, wenn ich später mehr Zeit habe.

Holzkohle , 54 52 Bytes

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

Erläuterung:

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

Meine vorherige Antwort war in Retina, einer Sprache, auf die ich noch keine Antwort gepostet habe. Jetzt haben Sie eine Antwort in Charcoal, auf die ich noch keine Antwort gepostet habe.

Probieren Sie es online aus!

PHP, 209 200 137 135 Bytes

endlich JS schlagen :)

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

Nimmt Eingaben von STDIN entgegen; Laufen Sie mit -nRoder bestellen Sie eine Familienpizza .

Nervenzusammenbruch

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

Dies ist mein erster ASCII-Kunst- Beitrag!

Fügen Sie f=am Anfang ein hinzu und rufen Sie like auf 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``}

Hinweis: Alle Zeilenumbrüche sind notwendig!

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

Erläuterung

Der Code deklariert zuerst ein Array a. Es deklariert wund uhat dann den Wert von Leerzeichen bzw. Unterstrich. Dann deklariert es eine String-Variable, die den Wert der Kruste enthält (der von berechnet werden kann /\+(n*3+2 underscores)+/\, wie in der Challenge erwähnt). Danach wird mit einer forSchleife und a Template Literaldie Mitte der Pizza erstellt (wobei jede Ebene iLeerzeichen am Anfang und (n+1-i*2)+n+(n-1)Leerzeichen zwischen \ \und hat / /, wobei ider Index der forSchleife steht). Zuletzt wird der unterste Teil der Pizza erstellt ( (i whitespaces)+\+(n+2 underscores)+/). Alle Teile werden zusammengefügt und ausgegeben (ted).

Wenn das Snippet aus irgendeinem Grund die ASCII-Grafik nicht korrekt anzeigt, schauen Sie hier .

Wir wünschen allen einen schönen Deep Dish Pizza Day!

Stapel, 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%_/

tenthält den linken Einzug, während er sdas Innere enthält; Seine _s werden durch Leerzeichen in den mittleren Zeilen ersetzt. lexistiert nur, um Wiederholungen zu vermeiden.

V , 57 Bytes

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

Probieren Sie es online aus!

Da dies (wie üblich) viele böse Nicht-ASCII-Zeichen und nicht druckbare Zeichen enthält, ist hier ein 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.

Ich werde bald eine detailliertere Erklärung veröffentlichen, aber hier ist eine allgemeine Übersicht:

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 (Klirren) , 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);}

Probieren Sie es online aus!

Hübscher 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);
}

Bearbeitungen:

• s [l] entfernt und durch Umschalten von% zugeordnet. s Notation zu% .s
• Funktions-Wrapper für Compliance hinzugefügt und online testen

CJam, 74 Bytes

Viel zu lange. Ich werde einen anderen Ansatz versuchen.

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

Erstellt die Zeichenfolge zeilenweise. Nichts zu verrückt.

CJam, 89 Bytes

Nun, das ist im Moment tatsächlich länger als meine andere Lösung, aber ich denke, es ist golffähiger:

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

Stapelspur:

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