Il 5 aprile è il National Deep DIsh Pizza Day, il tema di questa sfida. Dato un numero intero positivo n( nè maggiore di 0), crea una pizza per piatti profondi ASCII. Pizza per piatti profondi reali mostrata:

Come puoi vedere, c'è uno strato di crosta sul fondo e che circonda il resto della pizza.

Come preparare la pizza

La crosta è composta da due strati. Il primo strato sarà nalto e n*3lungo. La lunghezza è il numero di caratteri (inclusi gli spazi) nella riga più alta. Quindi dato n1 è, il primo strato dovrebbe apparire così:

\_/  1 character tall
 3 characters long

Se nè due:

\    /   2 characters tall
 \__/
  6 characters long

Ora per il secondo strato della crosta. Andrà al di fuori della prima crosta interiore, quindi sarà n+2alto e (n*3)+6)lungo. Dato nè uno:

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

Se nè due:

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

Dovresti quindi abbinare le due coppie più alte l'una \/con l'altra per la crosta interna ed esterna. In nè 1:

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

Se fatto correttamente, sembrerebbe una V senza le parti superiori con una differenza di un carattere tra ogni livello. Parlando di cime, la crosta sarà unita da una coppia di /\, separati da una linea di sottolineature (n*3)+2lunghe per completare la crosta e la pizza.

Esempi

Se nè 1:

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

n è 2:

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

n è 3:

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

Criterio vincente

Questo è code-golf , quindi vince il codice più corto in byte!

Carbone , 35 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

Ｎθ

Inserisci la dimensione della pizza.

←_←×_θ

Stampa parte della base esterna della crosta.

↖θ↖²

Stampa il lato esterno della crosta.

Ｍ→/Ｐ×_⁺²×²θ

Stampa parte della crosta superiore.

↘θ↘¹\

Stampa la parte interna sinistra della crosta.

×_θ

Stampa parte della base interna della crosta.

‖ＢＯθ

Rifletti per completare la pizza.

Si noti che le aggiunte moderne al carbone riducono le dimensioni fino a 31 byte:

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

Provalo online! Il collegamento è alla versione dettagliata del codice.

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>

Tutta la pizza è molto ripetitiva, quindi la rfunzione (progettata come un modello con tag letterale) ripete il primo carattere dei suoi ntempi di input . Questo gestisce le due linee superiore e inferiore della pizza. Il centro viene ripetuto sostituendo una stringa di spazi vuoti; le sottosezioni $`e $'corrispondono automaticamente al numero crescente e decrescente di spazi vuoti posizionando così \ \e in modo / /appropriato.

Python 2, 153 151 byte

Provalo online

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 byte sostituendo valori ripetuti con variabili grazie a @KoishoreRoy

MATLAB, 333 byte

(Tentativo pigro)

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

formattato:

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'idea di base è che ho maniglie di funzione per stampare tutto, e poi ho praticamente forza bruta. Quello per il ciclo è per gli nstrati tra la parte superiore e la parte inferiore dello strato interno. La ripetizione di (spazi) e _viene eseguita utilizzando arrayfun, con input di array. Proverò a pensare a modi più interessanti per farlo se avrò più tempo in seguito.

Carbone , 54 52 byte

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

Spiegazione:

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

La mia risposta precedente era in Retina, una lingua a cui non avevo mai pubblicato una risposta prima. Ora, hai una risposta in Carbone, a cui non ho ancora pubblicato una risposta.

Provalo online!

PHP, 209 200 137 135 byte

finalmente battendo JS :)

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

Riceve input da STDIN; correre con -nRo ordinare una pizza di famiglia .

abbattersi

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

Questo è il mio primo post su ASCII-art !

Aggiungi f=a all'inizio e invoca 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``}

Nota: sono necessarie tutte le interruzioni di riga!

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

Spiegazione

Il codice dichiara innanzitutto un array a. Dichiara quindi we uha rispettivamente il valore di spazi bianchi e trattini bassi. Quindi, dichiara una variabile String per contenere il valore della crosta (che può essere calcolata /\+(n*3+2 underscores)+/\, come menzionato nella Sfida). Dopodiché, con un forloop e un Template Literal, viene creato il centro della pizza (con ogni strato con ispazi bianchi all'inizio e (n+1-i*2)+n+(n-1)spazi bianchi tra \ \e / /, dove irappresenta l'indice del forloop). Alla fine, viene creata la parte inferiore della pizza ( (i whitespaces)+\+(n+2 underscores)+/). Tutte le parti sono unite e prodotte (ted).

Se per qualche motivo lo snippet non visualizza correttamente l'arte ASCII, dai un'occhiata qui .

Buona Deep Dish Pizza Day a tutti!

Lotto, 200 byte

@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 il rientro sinistro mentre scontiene l'interno; i suoi _s sono sostituiti da spazi nelle file centrali. lesiste solo per evitare qualche ripetizione.

V , 57 byte

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

Provalo online!

Poiché, come al solito, questo contiene molti cattivi caratteri non ASCII e non stampabili, ecco 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.

Pubblicherò presto una spiegazione più dettagliata, ma ecco una panoramica di alto livello:

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 byte

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

Provalo online!

Codice grazioso:

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

modifiche:

• rimosso s [l] e associato passando da%. s notazione a% .s
• aggiunto wrapper di funzioni per conformità e provalo online

CJam, 74 byte

Way troppo a lungo. Proverò un altro approccio.

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

Crea la stringa riga per riga. Niente di troppo folle.

CJam, 89 byte

Bene, questo è in realtà più lungo della mia altra soluzione al momento, ma penso che sia più golfabile:

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

Traccia dello stack:

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