4 월 5 일은이 도전의 주제 인 National Deep DIsh Pizza Day입니다. 양의 정수 n( n0보다 큼)가 주어지면 ASCII 딥 디쉬 피자를 만듭니다. 실제 딥 디쉬 피자 표시 :

보시다시피 바닥과 피자의 나머지 부분을 감싸는 지각 층이 있습니다.

피자 만드는 법

크러스트는 두 개의 층으로 구성됩니다. 첫 번째 층은 n키가 n*3길고 길다. 길이는 가장 높은 줄의 문자 수 (공백 포함)입니다. n1이 주어지면 첫 번째 레이어는 다음과 같습니다.

\_/  1 character tall
 3 characters long

n두 경우 :

\    /   2 characters tall
 \__/
  6 characters long

이제 지각의 두 번째 층입니다. 첫 번째 내부 크러스트 외부 로 이동 하므로 n+2키가 크고 (n*3)+6)문자가 길어집니다. 주어진 n것은 :

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

n두 경우 :

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

그런 다음 \/내부 및 외부 크러스트에 대해 두 개의 가장 높은 쌍을 서로 일치시킵니다 . 에서 n1입니다 :

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

올바르게 수행하면 각 레이어마다 한 문자 차이가있는 상단이없는 V처럼 보입니다. 상판에 대해 말하면, 지각은 한 쌍 /\의 밑줄로 분리되어 (n*3)+2지각과 피자를 완성하기 위해 긴 줄로 분리됩니다 .

예

n1 인 경우 :

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

n 2 :

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

n 3 :

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

승리 기준

이것은 code-golf 이므로 바이트 단위의 가장 짧은 코드가 이깁니다!

숯 , 35 바이트

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

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. 설명:

Ｎθ

피자의 크기를 입력하십시오.

←_←×_θ

외부 크러스트베이스의 일부를 인쇄하십시오.

↖θ↖²

바깥 쪽 표면을 왼쪽으로 인쇄하십시오.

Ｍ→/Ｐ×_⁺²×²θ

상단 크러스트의 일부를 인쇄하십시오.

↘θ↘¹\

내부 크러스트 왼쪽을 인쇄합니다.

×_θ

내부 크러스트베이스의 일부를 인쇄하십시오.

‖ＢＯθ

피자를 완성하십시오.

Charcoal에 현대식으로 추가하면 크기가 31 바이트로 줄어 듭니다.

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

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다.

자바 스크립트 (ES6), 136 바이트

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>

전체 피자는 매우 반복적이므로 r(태그 된 템플릿 리터럴로 설계된) 함수는 입력 n시간 의 첫 문자를 반복합니다 . 피자의 상단과 하단 두 줄을 처리합니다. 가운데는 빈 줄을 대체하여 반복됩니다. $`및 $'subsitutions 자동 따라서 위치 증가 블랭크의 수의 감소에 대응 \ \하고 / /적절.

파이썬 2, 153151 바이트

온라인으로 사용해보십시오

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+'_/'

@KoishoreRoy 덕분에 반복되는 값을 변수로 대체하여 -2 바이트

MATLAB, 333 바이트

(게으른 시도)

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

형식화 :

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

기본 아이디어는 모든 것을 인쇄하는 함수 핸들이 있고 거의 무차별 강제한다는 것입니다. for 루프는 n내부 레이어의 맨 위와 맨 아래 사이의 레이어입니다. (공백) 의 반복은 배열 입력과 함께를 _사용하여 수행됩니다 arrayfun. 나중에 시간이 더 걸리면 더 재미있는 방법을 생각할 것입니다.

숯 , 54 52 바이트

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

설명:

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

이전 답변은 이전에 답변을 게시하지 않은 언어 인 Retina에있었습니다. 자, 당신은 Charcoal에 대한 답변을 얻었습니다.

온라인으로 사용해보십시오!

PHP, 209200137135 바이트

마침내 JS를 때리는 :)

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

STDIN에서 입력을받습니다. 와 함께 -nR또는가족 피자 주문 주문하십시오 .

고장

// 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,_),"/";

자바 스크립트 (ES6), 205 바이트

이것은 나의 첫 아스키 아트입니다 포스트입니다!

f=시작 부분에를 추가하고 처럼 호출하십시오 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``}

참고 : 모든 줄 바꿈이 필요합니다!

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

설명

코드는 먼저 Array를 선언합니다 a. 그런 다음 공백과 밑줄의 값을 각각 선언 w하고 u갖습니다. 그런 다음 크러스트의 값을 보유하도록 String 변수를 선언합니다 ( /\+(n*3+2 underscores)+/\챌린지에 언급 된대로 계산할 수 있음 ). 그 후, for루프와 a Template Literal를 사용하여 피자의 중간이 만들어집니다 (각 레이어 i는 시작 부분에 (n+1-i*2)+n+(n-1)공백이 \ \있고 및 사이에 공백이 있습니다 / /. 여기서, 루프 i색인을 나타냅니다 for). 마지막으로 피자의 맨 아래 부분이 만들어집니다 ( (i whitespaces)+\+(n+2 underscores)+/). 모든 부품이 함께 결합되어 출력됩니다 (ted).

어떤 이유로 스 니펫이 ASCII 아트를 올바르게 표시하지 않으면 여기를보십시오 .

모두에게 행복한 딥 디쉬 피자의 날!

배치, 200 바이트

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

ts내부 를 포함하는 동안 왼쪽 들여 쓰기를 포함합니다. 그것 _의 가운데 줄에 공백으로 대체됩니다. l반복을 피하기 위해 존재합니다.

V , 57 바이트

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

온라인으로 사용해보십시오!

(평소와 같이) 여기에는 많은 비 ASCII 문자와 인쇄 할 수없는 문자가 포함되어 있으므로 다음은 16 진수 덤프입니다.

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.

더 자세한 설명을 곧 게시 할 예정이지만 다음은 대략적인 개요입니다.

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 (연타) , 211 (215) 바이트

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

온라인으로 사용해보십시오!

예쁜 코드 :

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

편집 :

• s [l]를 제거하고 %에서 전환하여 관련됨. 의 표기법 % .S
• 규정 준수를위한 기능 래퍼 추가 및 온라인 사용해보기

CJam, 74 바이트

방법 너무 오래. 다른 접근법을 시도 할 것입니다.

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

문자열을 한 줄씩 작성합니다. 너무 미친 것도 없습니다.

CJam, 89 바이트

글쎄, 이것은 현재 다른 솔루션보다 실제로 길지만 더 골프 타는 것 같습니다.

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

스택 추적 :

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