पिज्जा, पिज्जा, डीप डिश पिज्जा!

Question

5 अप्रैल को राष्ट्रीय दीप दिवस पिज्जा दिवस है, इस चुनौती का विषय है। एक सकारात्मक पूर्णांक 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

आप तब \/आंतरिक और बाहरी पपड़ी के लिए एक दूसरे के साथ दो उच्चतम जोड़े का मिलान करेंगे । 1 में nहै:

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

यदि सही ढंग से किया जाता है, तो यह प्रत्येक परत के बीच एक वर्ण अंतर के साथ सबसे ऊपर बिना वी की तरह दिखेगा। सबसे ऊपर की बात करें तो क्रस्ट एक जोड़ी से जुड़ जाएगा /\, (n*3)+2जो क्रस्ट और पिज्जा को पूरा करने के लिए अंडरस्कोर की लंबी लाइन से अलग हो जाएगा।

उदाहरण

यदि n1 है:

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

n 2 है:

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

n 3 है:

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

जीत का मानदंड

यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे छोटा कोड जीत जाता है!

Comments

भीतर की पपड़ी के उदाहरणों में कुछ दिखता है। N = 1 के लिए एक छोटा लगता है, n = 2 के लिए एक अंतिम n = 1 उदाहरण, आदि से आंतरिक पपड़ी की तरह दिखता है ...

— Adám

क्या हम -इसके बजाय उपयोग कर सकते हैं _?

— ओकेक्स

@ ओकेएक्स नहीं, आप नहीं कर सकते हैं

— एंथनी फाम

हैप्पी दीप डिश पिज्जा डे!

— अर्जुन

Answer 1

चारकोल , 35 बाइट्स

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

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

Ｎθ

पिज्जा का आकार इनपुट करें।

←_←×_θ

बाहरी क्रस्ट बेस का प्रिंट भाग।

↖θ↖²

बाहरी क्रस्ट बाईं ओर प्रिंट करें।

Ｍ→/Ｐ×_⁺²×²θ

शीर्ष क्रस्ट का हिस्सा प्रिंट करें।

↘θ↘¹\

आंतरिक क्रस्ट बाईं ओर प्रिंट करें।

×_θ

आंतरिक क्रस्ट बेस का प्रिंट भाग।

‖ＢＯθ

पिज्जा को पूरा करने के लिए प्रतिबिंबित करें।

ध्यान दें कि चारकोल के आधुनिक परिवर्धन आकार को 31 बाइट्स तक कम करते हैं:

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

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है।

Comments

सुनिश्चित नहीं है कि अगर मैंने गलती से बग की शुरुआत की है, लेकिन फिलिंग ठीक से काम नहीं कर रही है?

— केवल

@ ASCII- केवल भरना? टेस्ट केस कम से कम मुझे सही लगता है; आपको क्या लगता है क्या काम नहीं कर रहा है?

— नील

मुझे लगता है कि यह 4 और ऊपर के इनपुट के साथ काम नहीं करता है?

— केवल

@ ASCII- केवल हू, मैंने कैसे अनदेखी की ...

— नील

Answer 2

जावास्क्रिप्ट (ईएस 6), 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 स्वचालित रूप से बढ़ रही है और रिक्त स्थान की संख्या कम हो रही इस प्रकार की स्थिति के अनुरूप \ \और / /उचित रूप से।

Answer 3

पायथन 2, 153 151 बाइट्स

इसे ऑनलाइन आज़माएं

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 बाइट्स को @KoishoreRoy के साथ वेरिएबल धन्यवाद के साथ दोहराया मूल्यों को प्रतिस्थापित करके

Comments

इसकी जगह print' '*=~n+'\\'+'_'*-~n+'_/'आप नहीं लिख सकते print' '*i+' \\_'+'_'*n+'_/'? (या के nबजाय i, लेकिन मैं पिछली पंक्ति की नकल कर रहा था।)

— नील

@Neil मैं नहीं बदल सकते -~nकरने के लिए iक्योंकि इस बिंदु पर, i==n। लेकिन दूसरा बदलाव अच्छा है। इसके अलावा मैंने छोटा किया -~n, आपके विचार के लिए धन्यवाद

— डेड पॉसम

मैं बस में बदलाव नहीं किया गया था -~nकरने के लिए i, क्योंकि मैं अंतरिक्ष जोड़ने था। (लेकिन आपको लगता है कि अपने दम पर काम किया है। इसके अलावा मैं पहले से ही उल्लेख किया है nऔर iइस बिंदु पर एक ही हैं।)

— नील

Answer 4

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

मूल विचार यह है कि मेरे पास सब कुछ प्रिंट करने के लिए फ़ंक्शन हैंडल हैं, और फिर मैं बस बहुत ही क्रूरतापूर्वक बल देता हूं। लूप के लिए एक nबहुत ऊपर और नीचे की परत के बीच की परतों के लिए है। (रिक्त स्थान) की पुनरावृत्ति और सरणी इनपुट के साथ, _का उपयोग किया जाता है arrayfun। ऐसा करने के लिए और अधिक दिलचस्प तरीकों के बारे में सोचने की कोशिश करूंगा यदि मुझे बाद में अधिक समय मिलता है।

Comments

इसे ऑनलाइन आज़माएं! (ऑक्टेव में)

— लुइस मेंडो

Answer 5

लकड़ी का कोयला , 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

मेरा पिछला जवाब रेटिना में था, एक ऐसी भाषा जिसके बारे में मैंने पहले कोई जवाब नहीं दिया था। अब, आपके पास चारकोल में एक उत्तर है, जिसे मैंने पहले कोई उत्तर नहीं दिया है।

इसे ऑनलाइन आज़माएं!

Answer 6

PHP, 209 200 137 135 बाइट्स

अंत में जेएस की पिटाई :)

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

एसटीडीआईएन से इनपुट लेता है; परिवार पिज्जा के साथ चलाएं -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,_),"/";

Answer 7

जावास्क्रिप्ट (ईएस 6), 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">

---

व्याख्या

कोड पहले एक ऐरे की घोषणा करता है a। यह तब घोषित करता है wऔर uक्रमशः व्हाट्सएप और अंडरस्कोर का मूल्य रखता है। फिर, यह क्रस्ट के मान को धारण करने के लिए एक स्ट्रिंग वैरिएबल की घोषणा करता है (जिसे /\+(n*3+2 underscores)+/\चुनौती के अनुसार गणना की जा सकती है )। उसके बाद, एक forलूप और ए के साथ Template Literal, पिज्जा का मध्य बनाया जाता है ( iशुरुआत और (n+1-i*2)+n+(n-1)व्हाट्सएप के बीच \ \और / /जहां लूप iके सूचकांक का प्रतिनिधित्व करता है for) पर प्रत्येक परत के साथ व्हाट्सएप होता है । सबसे आखिर में पिज़्ज़ा का सबसे नीचे वाला हिस्सा ( (i whitespaces)+\+(n+2 underscores)+/) बनाया जाता है । सभी भाग एक साथ जुड़ते हैं और आउटपुट (टेड)।

---

यदि किसी कारण से स्निपेट ASCII कला को सही ढंग से प्रदर्शित नहीं करता है, तो यहां देखें ।

सभी को हैप्पी दीप डिश पिज्जा डे!

---

Answer 8

बैच, 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%_/

tबाईं ओर इंडेंट sहोता है जबकि अंदर होता है; इसकी _पंक्तियों को बीच की पंक्तियों के साथ स्थान दिया गया है। lबस कुछ पुनरावृत्ति से बचने के लिए मौजूद है।

Answer 9

वी , 57 बाइट्स

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

इसे ऑनलाइन आज़माएं!

चूंकि, (हमेशा की तरह) इसमें बहुत सारे गैर-गैर-एएससीआईआई अक्षर और unprintables शामिल हैं, यहाँ एक हेक्सडंप है:

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

Answer 10

सी (क्लैंग) , 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);
}

संपादन:

• हटाया गया [l] और% से स्विच करके संबद्ध है। रों अंकन करने के लिए% .s
• अनुपालन के लिए जोड़ा गया फ़ंक्शन आवरण और इसे ऑनलाइन आज़माएं

Comments

197 बाइट्स

— सीलिंगकैट

Answer 11

सीजेएम, 74 बाइट्स

रास्ता बहुत लंबा है। मैं एक और दृष्टिकोण की कोशिश करने जा रहा हूँ।

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

स्ट्रिंग लाइन-बाय लाइन बनाता है। कुछ भी पागल नहीं।

Answer 12

सीजेएम, 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]