27

पूर्णांक को देखते हुए, एक उल्टा तम्बू का उत्पादन होता है।

इनपुट टेंट के आकार (निरपेक्ष मूल्य) और क्या प्रवेश द्वार बाईं ओर (नकारात्मक संख्या) या दाईं ओर (सकारात्मक संख्या) दोनों को निर्धारित करता है।

If input = -1:
____
\/_/

If input = -2:
________
\  /   /
 \/___/

If input = -3:
____________
\    /     /
 \  /     /
  \/_____/

If input = 1:
____
\_\/

If input = 2:
________
\   \  /
 \___\/

If input = 3:
____________
\     \    /
 \     \  /
  \_____\/

et cetera

ध्यान दें कि तम्बू के ऊपर (यानी अंतिम पंक्ति) 2 * abs(input) - 1अंडरस्कोर है।

कोई अग्रणी स्थान नहीं हो सकता है , जैसे कि पहली पंक्ति सीधे अंडरस्कोर से शुरू होती है।

मान लें कि इनपुट कभी नहीं होगा 0।

आपका कोड यथासंभव छोटा होना चाहिए।

यह चुनौती हेल्का होम्बा की एक चैट मिनी चुनौती पर आधारित है , जिसे केल्विन के शौक सार्वजनिक लाइसेंस की शर्तों के तहत वास्तविक चुनौतियों में उपयोग करने की अनुमति है ।

code-golf ascii-art number

— user48538
स्रोत

1

रिक्त स्थान ठीक हैं? मतलब, क्या हम 3उदाहरण के लिए इनपुट के लिए 12 लंबाई (एक आयत) के चार तारों का उत्पादन कर सकते हैं ?

— AdmBorkBork

1

@TimmyD वे कर रहे हैं की अनुमति दी।

— user48538

2

@ टिम्मीड को यकीन है, कि शायद किसी और का भी एक डूप है, मैं वास्तव में निश्चित नहीं हूं कि श्रृंखला कहां से शुरू होती है। मुझे लगता है कि हमने अब तक इनमें से काफी देखा है।

— नथानिएल

5

मैं यह देखने में विफल रहता हूं कि कैसे प्रश्न दूर से भी मिलते-जुलते हैं। ज़रूर, वे दोनों आस्की-कला की चुनौतियाँ हैं जो एक संख्या लेते हैं और आपके पास किसी चीज़ के n-वें पुनरावृत्ति को आउटपुट करते हैं , लेकिन यही वह जगह है जहाँ समानता समाप्त होती है। यदि यह डुबकी के रूप में बंद करने के लिए पर्याप्त है, तो हमें किसी भी अधिक एएससी-कला चुनौतियों को नहीं लेना चाहिए ।

— DJMcMayhem

2

@Nathaniel दो चुनौतियों के लिए हमारी स्वीकृत गाइडलाइन डुप्लिकेट है कि क्या एक से उत्तर का पुन: उपयोग किया जा सकता है (प्रतिस्पर्धात्मक रूप से) दूसरे पर बहुत कम या बिना किसी संशोधन के। क्या चुनौतियां कुछ उपन्यास को तालिका में लाती हैं, यह उस दिशानिर्देश का हिस्सा नहीं है। कृपया उन चुनौतियों के लिए डाउनवोट्स का उपयोग करें जिन्हें आप हतोत्साहित करना चाहते हैं या बस उन्हें अनदेखा करें यदि उन्हें नहीं लगता कि वे दिलचस्प हैं और जो उन्हें आनंद देते हैं उन्हें दें।

— मार्टिन एंडर

11

MATL , 55 53 52 51 बाइट्स

|95cy4*Y"DXytPEt0*yvG0>?P_]!'\/ 'w)95JG|G0<yEq:++&(

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

व्याख्या

चलो Nइनपुट को दर्शाते हैं। कोड तीन चरणों में आगे बढ़ता है।

सबसे पहले , 4*Nअंडरस्कोर की पहली पंक्ति को एक स्ट्रिंग के रूप में बनाया गया है और प्रदर्शित किया जाता है (जो इसे स्टैक से निकालता है)।

दूसरा , तम्बू का "फ्रेम" दो प्रकार के स्लैश का उपयोग करके बनाया गया है। ऐसा करने के लिए, एक संख्यात्मक 2 डी सरणी बनाई गई है जिसमें 1और 2स्लैश के दो प्रकार के लिए इसी, और 0अंतरिक्ष के लिए।

यह चार मैट्रिंस को मिला कर किया जाता है:

आकार का एक पहचान मैट्रिक्स abs (N);
2एंटीडिओगल में समान आकार का एक मैट्रिक्स ;
एक ही आकार का एक शून्य मैट्रिक्स;
मैट्रिक्स 2 की एक प्रति।

N=3एक उदाहरण के रूप में, निम्नलिखित 4*N × Nमैट्रिक्स का उपयोग करते हुए, इन चार मातृ रेखाओं को समाप्‍त करता है :

(जो, प्रत्यारोपित, तम्बू की तरह लगने लगता है)।

अब हम इनपुट के संकेत का ध्यान रखते हैं। यदि यह सकारात्मक है तो हम उपर्युक्त मैट्रिक्स और इंडेक्स को स्ट्रिंग में स्थानांतरित करते हैं '\/ '। अनुक्रमण 1-आधारित है और मॉड्यूलर है, तो 1हो जाता है '\', 2हो जाता है '/'और 0हो जाता है ' ', 2 डी चार सरणी का निर्माण

\    /     /
 \  /     / 
  \/     /

दूसरी ओर, यदि इनपुट नकारात्मक है तो हम लंबवत रूप से पलते हैं और अंकगणित 4*N × Nमैट्रिक्स को नकारात्मक रूप से , उत्पादन करते हैं

सूचकांक -1अब को संदर्भित करता है '/'और -2करने के लिए '\'। अर्थात्, दो प्रकार के स्लैशों को आवश्यकतानुसार बदल दिया गया है। फिर से स्ट्रिंग में ट्रांसपोज़िंग और इंडेक्सिंग '\/ 'इस प्रकार उलट तम्बू देता है:

\     \    /
 \     \  / 
  \     \/

तीसरा , अंडरस्कोर को 2 डी चार सरणी की अंतिम पंक्ति के हिस्से में भरने की आवश्यकता है। इस रेखा की क्षैतिज स्थिति इनपुट के संकेत पर निर्भर करती है, और इसकी लीनता है abs(N)।

एक बार जब संबंधित रिक्त स्थान को अंडरस्कोर से बदल दिया गया है, तो परिणाम को पहले चरण में पहले से प्रदर्शित अंडरस्कोर की प्रारंभिक रेखा के नीचे प्रदर्शित किया गया है।

— लुइस मेंडो
स्रोत

उन लोगों को शुरू में रिक्त स्थान नहीं होना चाहिए?

— DJMcMayhem

@DJMcMayhem क्षमा करें, आपका क्या मतलब है?

— लुइस मेंडो

जब मैं आपका कोड चलाता हूं तो पहली पंक्ति सभी अंडरस्कोर होती है। आउटपुट ज़ैनबिन ने ऐसा नहीं किया है।

— DJMcMayhem

@DJMcMayhem मैं अनुसरण नहीं करता। परीक्षण मामलों में पहली पंक्ति अंडरस्कोर है, है ना? और अन्य जवाब (तुम्हारा नहीं) वह भी करते हैं?

— लुइस मेंडो

1

@DJMcMayhem :-D अजीब वास्तव में। एक अलग ब्राउज़र की कोशिश करो?

— लुइस मेंडो

9

जावास्क्रिप्ट (ईएस 6), 139 बाइट्स

तम्बू को पुन: बनाता है:

f=(N,n=N>0?N:-N,i=0,r=(j,i)=>' _'[i||0].repeat(j),a=`\\${r(i)}/`,b=r(n*2+i-1,+!i))=>n--?f(N,n,i+2)+`
`+r(n)+(N<0?a+b+'/':'\\'+b+a):r(i*2,1)

असहमति और टिप्पणी की

f = (
  N,                                  // N is the original parameter (remains unchanged)
  n = N > 0 ? N : -N,                 // n is initialized to abs(N)
  i = 0,                              // i is the row counter (*2)
  r = (j, i) => ' _'[i||0].repeat(j), // helper function to repeat ' ' or '_' j times
  a = `\\${r(i)}/`,                   // a = '\ /' pattern
  b = r(n*2+i-1, +!i)                 // b = padding pattern filled with ' ' or '_'
) =>
  n-- ?                               // if we haven't made it yet to the top row:
    f(N, n, i+2) + `\n` +             //   - compute next row(s) / append line break
    r(n) +                            //   - append leading spaces
    (N < 0 ? a+b+'/' : '\\'+b+a)      //   - append a/b patterns according to N sign
  :                                   // else:
    r(i*2, 1)                         //   - return top row, made of '_' characters

उदाहरण

var f=(N,n=N>0?N:-N,i=0,r=(j,i)=>' _'[i||0].repeat(j),a=`\\${r(i)}/`,b=r(n*2+i-1,+!i))=>n--?f(N,n,i+2)+`
`+r(n)+(N<0?a+b+'/':'\\'+b+a):r(i*2,1)

console.log(f(3));
console.log(f(-4));

स्निपेट का विस्तार करें

— Arnauld
स्रोत

6

पायथन 2, 143 141 139 138 137 बाइट्स

-2 बाइट्स @ Sp3000 के लिए धन्यवाद (पायथन 2 में कोष्ठक निष्पादन की कोई आवश्यकता नहीं)
-1 बाइट के लिए @ Sp3000 (उपयोग cmp) के लिए धन्यवाद

def f(n):d=cmp(n,0);a,b='\/'[::-d];s=n*d;x=2*s-1;y=4*s;print'_'*y;i=0;exec"print' '*i+(b+' '*(y-3-x-i-i)+a+'_ '[s-i>1]*x+a)[::d];i+=1;"*s

इसे आइडोन पर टेस्ट करें

पहले हम देखते हैं कि nक्या नकारात्मक है और d +1अगर यह है और -1नहीं है तो बनाएं ।
फिर हम दो स्लैश का चयन करते हैं, aऔर b, dइस तरह का उपयोग करते हुए कि a='\', b='/'कब nसकारात्मक है और a='/', b='\'कब nनकारात्मक है।
अगला हम निर्धारित करते हैं s=abs(n)कि कौन सा हासिल किया जा सकता है s=n*d।
फिर हम _सबसे ऊपर (चित्र के नीचे) की संख्या की गणना करते हैं , जो तम्बू के किनारे की संख्या भी है x=2*s-1।
फिर हम _तम्बू के आधार पर (चित्र के ऊपर) की संख्या की गणना करते हैं , और इसे स्टोर करते हैं y=4*sक्योंकि यह बाकी तम्बू को बनाने के लिए लूप में उपयोग किया जाएगा।
अब हम तम्बू के आधार का उपयोग करके प्रिंट करते हैं print'_'*y।
फिर हम एक प्रिंट sचर के साथ प्रिंट स्टेटमेंट को निष्पादित करके बाकी तम्बू को प्रिंट करते हैं, जो कि प्रत्येक प्रिंट स्टेटमेंट के लिए वेतन वृद्धि से iशुरू होता है । तम्बू के बाकी हिस्सों में दरवाजे और शरीर में रिक्त स्थान होते हैं जब तक कि शीर्ष तक नहीं पहुंच जाता है, जब फाल्स का मूल्यांकन होता है, जिसमें से उठा । एक सकारात्मक, बाएं-दरवाजे के लिए, पूरे तम्बू को तम्बू बनाएं, अग्रणी रिक्त स्थान को छोड़कर, बैक-टू-फ्रंट है, इसलिए यह सकारात्मक है, जबकि 'राइट-डोर', तम्बू के साथ नहीं है ।01
y-3-x-i-ixs-i>1_'_ '
[::d]

— जोनाथन एलन
स्रोत

@ Sp3000 दुर्भाग्य से cmp(0,0)रिटर्न0

— जोनाथन एलन

5

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

def f(n):i=k=abs(n);print'_'*k*4;exec"print' '*(k-i)+r'\\\%%s%\*%c%%*sc/'[n<0::2]%(' _'[i<2]*(2*k-1))%(2*i-1,47);i-=1;"*k

बस बहुत सारे स्ट्रिंग स्वरूपण।

— Sp3000
स्रोत

5

सी #, 215 214 बाइट्स

string t(int N){var n=N<0;N=n?-N:N;var t=new string('_',4*N);for(int i=0;i<N;){string f=new string(i<N-1?' ':'_',2*N-1),p=new string(' ',2*N-2*i-2);t+='\n'+new string(' ',i++)+'\\'+(n?p+'/'+f:f+'\\'+p)+'/';}return t;}

using s=string;पहले से उपयोग करते समय कुछ बाइट्स बचाने की संभावना है ।

s t(int N){var n=N<0;N=n?-N:N;var t=new s('_',4*N);for(int i=0;i<N;){s f=new s(i<N-1?' ':'_',2*N-1),p=new s(' ',2*N-2*i-2);t+='\n'+new s(' ',i++)+'\\'+(n?p+'/'+f:f+'\\'+p)+'/';}return t;}

जो 15 (का उपयोग करके) + 184 (विधि) = 199 बाइट्स होगा।

— BackFromExile
स्रोत

5

PPCG, BackFromExile में आपका स्वागत है!

— आउटगॉल्फ

दरअसल, PPCG में आपका स्वागत है! एक बहुत अच्छा पहला जवाब +1। मैंने गोल्फ में कुछ भी खोजने की कोशिश की (काफी समय बाद जब मैंने C # में प्रोग्राम किया था), और अंत में केवल 1 बाइट के लिए एक चीज खोजने में सक्षम था: यदि आप varफॉर-लूप के अंदर पहली बार बदलते हैं string, तो आप इसे हटा सकते हैं दूसरा var (बाइट बचाने के लिए स्थान सहित)। तो var fबन जाता है string f, और ;var p=बन जाता है ,p=।

— केविन क्रूज़सेन

4

TSQL, 195 बाइट्स

golfed:

DECLARE @ INT=-2
DECLARE @b INT=ABS(@),@i INT=0PRINT REPLICATE('_',4*@b)z:SET @i+=1PRINT SPACE(@i-1)+'\'+STUFF(REPLICATE(IIF(@i<@b,' ','_'),4*@b-2*@i),@b*2-IIF(@<0,@i*2-1,0),1,IIF(@<0,'/','\'))+'/'IF @i<@b GOTO z

Ungolfed:

DECLARE @ INT=-2

DECLARE @b INT=ABS(@),@i INT=0

PRINT REPLICATE('_',4*@b)
z:
  SET @i+=1
  PRINT 
    SPACE(@i-1)+'\'
    +STUFF(REPLICATE(IIF(@i<@b,' ','_'),
      4*@b-2*@i),@b*2-IIF(@<0,@i*2-1,0),1,IIF(@<0,'/','\'))
    +'/'
IF @i<@b GOTO z

बेला

— t-clausen.dk
स्रोत

4

वी , 66 बाइट्स

é /ä
"aDoÀñá_>ñ^hr\A\/ò^hÄX$2é_Ó_/ òÄÒ_ñ/-
ddÍÜ¨[ _]*©Ü¨ *©/Ü²¯±

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

यह एक बहुत अच्छा अनुभव है, इसलिए मैं इसे आज बाद में नीचे गोल्फ करने की कोशिश करूंगा। इस समाधान में अनपेक्षित वर्ण हैं, इसलिए यहां एक हेक्सडंप है:

0000000: e920 2fe4 0a22 6144 6f1b c0f1 e15f 3ef1  . /.."aDo...._>.
0000010: 5e68 725c 415c 2f1b f25e 68c4 5824 32e9  ^hr\A\/..^h.X$2.
0000020: 5fd3 5f2f 20f2 c4d2 5ff1 2f2d 0a64 64cd  _._/ ..._./-.dd.
0000030: dca8 5b20 5f5d 2aa9 dca8 202a a92f dcb2  ..[ _]*... *./..
0000040: afb1                                     ..

— DJMcMayhem
स्रोत

4

05AB1E , 52 बाइट्स

Ä©'_4®*×,FNð×'\®·<N>®Qi'_ëð}×®N>-·ð×®¹Qi'\ës'/}s'/J,

व्याख्या

                                                     # implicit input, call this A
Ä©                                                   # store abs(A) in register for later use
  '_4®*×,                                            # print 4*A underscores (tent floor)
         F                                           # for each non-floor section in range(N)
          Nð×'\                                      # push N spaces at the beginning of the 
                                                     # row followed by a backslash
                  N>®Qi'_ëð}                         # if we're on the last row push an
                                                     # underscore, else a space
               ®·<          ×                        # repeat that char abs(A)*2-1 times
                             ®N>-·ð×                 # push 2*(abs(A)-(N+1)) spaces
                                    ®¹Qi'\ës'/}      # if input is positive push backslash
                                                     # else push a slash
                                               s'/   # move that char between the 2 sections
                                                     # of spaces
                                                  J, # join the row and print

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

— Emigna
स्रोत

4

PowerShell v2 +, 217 205 190 187 184 बाइट्स

param($b)"_"*(($a=[math]::Abs($b))*4);$z,$y='/\'[($b=$b-lt0),!$b]
((($x=1..$a|%{($w=" "*($_-1))+$z+" "*(2*($a-$_))+$y+(' ','_')[$_-eq$a]*($a*2-1)+$y+$w})|%{-join$_[($a*4)..0]}),$x)[$b]

$bएक पूर्णांक के रूप में इनपुट लेता है । ध्यान दें कि यदि $bऋणात्मक है, तो आपको इसे उचित तरीके से (उदाहरण देखें) कास्ट करने के लिए इसे स्पष्ट रूप से पार्स के साथ घेरने की आवश्यकता है, अन्यथा PowerShell को लगता है कि यह एक स्ट्रिंग है।

चाहे जिस दिशा में तम्बू का सामना करना पड़ रहा हो, पहली पंक्ति समान होती है, अंडरस्कोर का एक गुच्छा; वास्तव में 4*abs(input)उनमें से कई, वास्तव में। उस नंबर को $aबाद में उपयोग के लिए भी संग्रहीत किया जाता है । साथ ही, अब हम का निरपेक्ष मान है कि $bमें संग्रहीत $aहै, हम बारी $bअपने हस्ताक्षर के लिए एक बूलियन में, और हमारे स्लैश में संग्रहीत चुनें $yऔर $z।

अगली पंक्ति आउटपुट का निर्माण और निर्माण कर रही है, और यह एक डोज़ी है, इसलिए इसे नीचे तोड़ दें।

हम अनिवार्य रूप से दो तत्वों की एक सरणी में अनुक्रमण कर रहे हैं, (big long calculations saved into $x)या $x, के आधार पर $b।

गणनाएं हैं जहां तम्बू शरीर का निर्माण किया जाता है। हम पाश से 1..$a|%{...}। प्रत्येक पुनरावृत्ति हम तम्बू शरीर की एक पंक्ति का निर्माण कर रहे हैं। हम पंक्ति # के बराबर कई स्थानों से शुरू करते हैं -1, ताकि हम उचित रूप से बाएं-संरेखित हों। इसे $wबाद में के लिए संग्रहीत किया जाता है, और उपयुक्त स्लैश ($ z, के आधार पर $b) के साथ, तब रिक्त स्थान की डोरफ्रेम संख्या, फिर दूसरे स्लैश $y, या तो अंडरस्कोर या रिक्त स्थान पर निर्भर करता है कि हम नीचे की रेखा पर हैं या नहीं। फिर एक और स्लैश $y, और अंत में $wआयताकार स्ट्रिंग के निर्माण के लिए अनुगामी रिक्त स्थान ( ) की उपयुक्त संख्या । जिसके परिणामस्वरूप स्ट्रिंग को सरणी में संग्रहीत किया जाता है $x।

सरणी के बाईं आधा चुना जाता है (यानी, $bहै False, तो हम के माध्यम से लूप करने की आवश्यकता है के बाद से इनपुट सकारात्मक था) $xऔर प्रत्येक लाइन आइटम रिवर्स - इस जगह है जहाँ अवांछित स्पेस भूमिका निभाते हैं; यह हमें दूरियों की पुन: गणना करने के बजाए लाइनों को उलटने की अनुमति देता है।

यदि $bहै True, तो $xइसके बजाय सरणी का दायां भाग चुना जाता है।

या तो मामले में, पाइपलाइन में अब एक सरणी होती है। Write-Outputतत्वों के बीच डिफ़ॉल्ट न्यूलाइन के साथ, कार्यक्रम के पूरा होने पर निहित उत्पादन होता है।

उदाहरण

PS C:\Tools\Scripts\golfing> .\print-upside-down-tent.ps1 (-5)
____________________
\        /         /
 \      /         / 
  \    /         /  
   \  /         /   
    \/_________/    

PS C:\Tools\Scripts\golfing> .\print-upside-down-tent.ps1 (4)
________________
\       \      /
 \       \    / 
  \       \  /  
   \_______\/

— AdmBorkBork
स्रोत

3

हास्केल, 187 184 183 बाइट्स

f x=unlines$[(n*4)%'_']++((' '#)<$>[0..n-2])++['_'#(n-1)]where m#i=i%' '++'\\':m!i++"/";m!i|x>0=(2*n-1)%m++'\\':(2*(n-i-1))%' '|q<-2*(n-i-1)=q%' '++'/':(2*n-1)%m;n=abs x;m%c=c<$[1..m]

मुझे ऐसा लगता है कि हास्केल के लिए यह शानदार स्कोर नहीं है, इसलिए सुधार के किसी भी विचार का स्वागत है।

3 बाइट्स @Myridium की बदौलत बच गए
1 बाइट @ @ मिमी के लिए धन्यवाद बचा लिया

Ungolfed

tent :: Int -> String
tent x = unlines $ [replicate (n*4) '_'] ++ (row ' '<$>[0..n-2]) ++ [row '_' (n-1)]
    where row m i = replicate i ' ' ++ "\\" ++ dir m i ++ "/"
          -- direction selector
          dir m i | x > 0 = side m ++ "\\" ++ entrance i ' '
                  | 1 > 0 = entrance i ' ' ++ "/" ++ side m
          side = replicate (2*n-1)
          entrance i = replicate (2*(n-i-1))
          n = abs x

— sudee
स्रोत

मेरे 290 बाइट्स से बेहतर मैं पोस्ट करने वाला था ...

— मैरिडियम

क्या आपको ऐसा नहीं जोड़ना चाहिए mainकि यह stdinइनपुट के रूप में स्वीकार हो ?

— मायरिडियम

जब तक प्रश्न अन्यथा निर्दिष्ट न हो, आप एक ही फ़ंक्शन पोस्ट कर सकते हैं। जवाब देने पर सामान्य नियमों के लिए एक मेटा थ्रेड है, मैं इसे आपके लिए खोजने की कोशिश करूंगा।

— सूडी

1

जहाँ आप वर्ण का उपयोग करने के लिए किसी एकल वर्ण को रोकते हैं उसे बदलकर आप 2 बाइट्स बचा सकते हैं :। यानी में बदल "\\" ++ entrance...जाते हैं '\\':entrance।

— मैरिडियम

1

"नहीं तो" गार्ड को व्यर्थ न गवाएं : आप बदल सकते हैं |1>0=(2*(n-i-1))%' 'करने के लिए |q<-2*(n-i-1)=q%' '।

— नीमी

2

सी, 240 207 193 बाइट्स

#define P putchar
a,j,l,m;g(x,y,z){for(m=y+z+1;m--;P(m^z?l?32:95:x));}f(n){g(32,(a=abs(n))*4,0);for(P(10),j=2*(l=a)-1;l--;){for(m=a;--m>l;P(32));P(92);m=n>0?g(92,j,l*2):g(47,l*2,j);puts("/");}}

इस बार मैंने फंक्शन जी (...) को लूप के लिए सिंगल का उपयोग करने के लिए ऑप्टिमाइज़ किया।

#define P putchar
a,j,l,m;g(x,y,z){for(;y--;P(l?32:95));for(P(x);z--;P(l?32:95));}f(n){g(32,(a=abs(n))*4,0);l=a;j=2*a-1;P(10);for(;l--;){for(m=a;--m>l;P(32));P(92);m=n>0?g(92,j,l*2):g(47,l*2,j);puts("/");}}

इस बार मैक्रो X एक फंक्शन जी (...) के रूप में बेहतर है और चूंकि y और z एक नए दायरे में पैरामीटर हैं इसलिए मैं उन्हें केवल g के दायरे में घटा सकता हूं।

#define P putchar
#define X(x,y,z){for(k=0;k++<y;P(l?32:95));P(x);for(k=0;k++<z;P(l?32:95));}
a,i,j,k,l,m;f(n){for(l=a=abs(n);i++<a*4;P(95));j=2*a-1;P(10);while(l--){for(m=a;--m>l;P(32));P(92);if(n>0)X(92,j,l*2)else X(47,l*2,j)puts("/");}}

इस मुख्य कार्य के साथ परीक्षण करें; यह बहुत छोटा होना चाहिए।

main(c,v)char**v;
{
    f(atoi(v[1]));
}

— cleblanc
स्रोत

2

सी # 241 231 बाइट्स

सहेजे गए 10 बाइट @Kevin क्रूज़सेन की बदौलत

using s=System.String;s f(int N){var f=N<0;N=N>0?N:-N;var o=new s('_',N*4);for(int j=0,z;j<N;){z=-2*j+2*N-2;var O=j>N-2?'_':' ';o+='\n'+new s(' ',j)+'\\'+new s(' ',z)+(f?'/':O)+new s(O,j++*2)+(f?O:'\\')+new s(' ',z)+'/';}return o;}

पुराना संस्करण:

string f(int N){var f=N<0;N=N>0?N:-N;var o=new string('_',N*4);for(int j=0;j<N;){int z=-2*j+2*N-2;var O=j>N-2?'_':' ';o+='\n'+new string(' ',j)+'\\'+new string(' ',z)+(f?'/':O)+new string(O,j++*2)+(f?O:'\\')+new string(' ',z)+'/';}return o;}

मूल new string(...)रूप Func<char,int,string>से कंस्ट्रक्टर का उपयोग करते हुए एक बाइट के रूप में बचा था। काश int-> charनिहित होता

बहुत यकीन है कि मेरा गणित किसी तरह भी तय किया जा सकता है, लेकिन मैं इसे नहीं देख सकता

— pinkfloydx33
स्रोत

1

आप इसे कुछ और गोल्फ कर सकते हैं। सबसे पहले आप इसे फॉर-लूप में जोड़कर int पहले हटा सकते हैं :। और जब से आप काफी उपयोग करते हैं , तो आप इसे उर्फ के साथ बदल सकते हैं , कुल योग बन जाता है: ( 231 बाइट्स )z=int j=0,zstringusing s=System.String;

using s=System.String;s f(int N){var f=N<0;N=N>0?N:-N;var o=new s('_',N*4);for(int j=0,z;j<N;){z=-2*j+2*N-2;var O=j>N-2?'_':' ';o+='\n'+new s(' ',j)+'\\'+new s(' ',z)+(f?'/':O)+new s(O,j++*2)+(f?O:'\\')+new s(' ',z)+'/';}return o;}

— केविन क्रूज़सेन

1

स्विफ्ट 2.2 421 बाइट्स

खैर ... यह एक प्रयास था।

golfed:

let t={(s:String,n:Int)->String in return String(count:n,repeatedValue:Character(s))};let e={(n:Int)in var w=[String]();w.append(t("_",abs(n)*4));let c = abs(n);let d = n>0 ? "/": "\\";let f = n>0 ? "\\": "/";for var i in 0...abs(n)-1 {w.append(t(" ",i)+d+t(" ",c*2-2-(2*i))+f+(i<c-1 ?t(" ",2*c-1)+f:t("_",2*c-1)+f)+(n>0 ?t(" ",i):""));};w=n<0 ?w:w.map(){String($0.characters.reverse())};print(w.joinWithSeparator("\n"))}

UnGolfed:

let t={(s:String,n:Int) -> String in
    return String(count:n,repeatedValue:Character(s))
};
let e={(n:Int) in
    var w=[String]();
    w.append(t("_",abs(n)*4));
    let c = abs(n);
    let d = n>0 ? "/": "\\";
    let f = n>0 ? "\\": "/";
    for var i in 0...abs(n)-1 {
        w.append(t(" ",i)+d+t(" ",c*2-2-(2*i))+f+(i<c-1 ?t(" ",2*c-1)+f:t("_",2*c-1)+f)+(n>0 ?t(" ",i):""));
    };
    w=n<0 ?w:w.map(){String($0.characters.reverse())};
    print(w.joinWithSeparator("\n"))
}

— Danwakeem
स्रोत

1

PHP, 143 बाइट्स

$t=str_repeat;echo$t(_,4*$s=$k=abs($n=$argv[1]));for(;$k--;$p.=" "){$f=$t("  ",$k);$r=$t($k?" ":_,2*$s-1);echo"
$p\\",$n<0?"$f/$r/":"$r\\$f/";}

साथ दौड़ो php -r '<code>' <parameter>

टूट - फूट

$t=str_repeat;  // function name to variable saves 10-1 bytes
echo$t(_,4*$s=$k=abs($n=$argv[1])); // print bottom
for(
    ;
    $k--;   // $k from abs($n-1) to 0
    $p.=" "                 // create padding
)
{
    $f=$t("  ",$k);         // create front
    $r=$t($k?" ":_,2*$s-1); // create side/roof
    echo"\n$p\\",$n<0
        ?"$f/$r/"   // print, entrance left
        :"$r\\$f/"  // print, entrance right
    ;
}

— टाइटस
स्रोत

1

बैच, 289 बाइट्स

@echo off
set/pn=
set u=
for /l %%i in (2,1,%n:-=%)do call set u=_%%u%%_
echo _%u%__%u%_
set l=
set m=%u%/_%u%
if %n% gtr 0 set m=%u%_\%u%
set m=%m:_= %
for /l %%i in (2,1,%n:-=%)do call:l
set m=%m: =_%
:l
echo %l%\%m%/
set l= %l%
if %n% gtr 0 set m=  %m:~0,-2%
set m=%m:~2%

STDIN पर इनपुट लेता है। 2*(abs(n)-1)अंडरस्कोर की एक स्ट्रिंग बनाकर शुरू होता है । इसके बाद तम्बू के आधार के लिए अतिरिक्त 4 अंडरस्कोर को दोहराया जाता है। तम्बू के बाकी हिस्सों में एक इंडेंट होता है (जो प्रत्येक पंक्ति पर 1 से बढ़ता है), ए \, तम्बू के मध्य और ए /। तम्बू के बीच में 2*(abs(n)-1)रिक्त स्थान के रूप में , प्लस या तो एक स्थान \या /प्लस (जो मैं मार्कडाउन में प्रतिनिधित्व नहीं कर सकता) शुरू होता है, साथ ही एक और 2*(abs(n)-1)स्थान। मैं अंडरस्कोर स्ट्रिंग का पुन: उपयोग करता हूं और उन्हें सुविधा के लिए रिक्त स्थान में परिवर्तित करता हूं, लेकिन फिर अंतिम पंक्ति के लिए रिक्त स्थान को अंडरस्कोर में बदल देता हूं। प्रत्येक पंक्ति तम्बू के मध्य में एक तरफ से दो स्थानों को हटाती है, हालांकि यदि आवश्यक हो तो पहले दो स्थानों को स्ट्रिंग की शुरुआत में स्थानांतरित करने के लिए थोड़ा गोल्फ खिलाड़ी है।

— नील
स्रोत

1

कैनवस , 25 बाइट्स

⤢＼║ｌ╵：╷：«_×╋ｌ／＋Ｌ_×；∔⁸０＞？↔

यहाँ कोशिश करो!

— dzaima
स्रोत

एक उल्टा तम्बू उत्पादन

MATL , 55 53 52 51 बाइट्स

व्याख्या

जावास्क्रिप्ट (ईएस 6), 139 बाइट्स

असहमति और टिप्पणी की

उदाहरण

पायथन 2, 143 141 139 138 137 बाइट्स

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

सी #, 215 214 बाइट्स

TSQL, 195 बाइट्स

वी , 66 बाइट्स

05AB1E , 52 बाइट्स

PowerShell v2 +, 217 205 190 187 184 बाइट्स

उदाहरण

हास्केल, 187 184 183 बाइट्स

सी, 240 207 193 बाइट्स

सी # 241 231 बाइट्स

स्विफ्ट 2.2 421 बाइट्स

PHP, 143 बाइट्स

बैच, 289 बाइट्स

कैनवस , 25 बाइट्स