13

(इस SO प्रश्न से प्रेरित )

आपको इनपुट के रूप में एकल पॉजिटिव पूर्णांक n दिया गया है ।

संभव के रूप में कुछ पात्रों में, ASCII कला में एक रॉकेट एक सिर, एक पूंछ और एक शरीर से बना है जो एन सेगमेंट से बना है । कोई अनुगामी स्थान या नई सीमा नहीं होनी चाहिए।

रॉकेट के सिर और पूंछ हमेशा n के किसी भी मूल्य के लिए समान होते हैं । शरीर में दो अलग-अलग प्रकार के खंड होते हैं जो वैकल्पिक होते हैं। उदाहरणों को रॉकेट की संरचना को स्पष्ट करना चाहिए।

N = 1 के लिए आउटपुट :

     /**\
    //**\\
   ///**\\\
  ////**\\\\
 /////**\\\\\
+=*=*=*=*=*=*+
|\/\/\/\/\/\/|
|.\/\/..\/\/.|
|..\/....\/..|
|../\..../\..|
|./\/\../\/\.|
|/\/\/\/\/\/\|
+=*=*=*=*=*=*+
     /**\
    //**\\
   ///**\\\
  ////**\\\\
 /////**\\\\\

N = 2 के लिए आउटपुट :

     /**\
    //**\\
   ///**\\\
  ////**\\\\
 /////**\\\\\
+=*=*=*=*=*=*+
|../\..../\..|
|./\/\../\/\.|
|/\/\/\/\/\/\|
|\/\/\/\/\/\/|
|.\/\/..\/\/.|
|..\/....\/..|
+=*=*=*=*=*=*+
|\/\/\/\/\/\/|
|.\/\/..\/\/.|
|..\/....\/..|
|../\..../\..|
|./\/\../\/\.|
|/\/\/\/\/\/\|
+=*=*=*=*=*=*+
     /**\
    //**\\
   ///**\\\
  ////**\\\\
 /////**\\\\\

N = 3 के लिए आउटपुट :

     /**\
    //**\\
   ///**\\\
  ////**\\\\
 /////**\\\\\
+=*=*=*=*=*=*+
|\/\/\/\/\/\/|
|.\/\/..\/\/.|
|..\/....\/..|
|../\..../\..|
|./\/\../\/\.|
|/\/\/\/\/\/\|
+=*=*=*=*=*=*+
|../\..../\..|
|./\/\../\/\.|
|/\/\/\/\/\/\|
|\/\/\/\/\/\/|
|.\/\/..\/\/.|
|..\/....\/..|
+=*=*=*=*=*=*+
|\/\/\/\/\/\/|
|.\/\/..\/\/.|
|..\/....\/..|
|../\..../\..|
|./\/\../\/\.|
|/\/\/\/\/\/\|
+=*=*=*=*=*=*+
     /**\
    //**\\
   ///**\\\
  ////**\\\\
 /////**\\\\\

code-golf ascii-art kolmogorov-complexity

— चिरायता
स्रोत

3

संबंधित पोस्ट, हमारी दासता से: codereview.stackexchange.com/questions/65040/…

CJam, 67 63 वर्ण

"дȈ鰚㒄å摒四ㄺ뎞椉ᖛⲠ줥葌⌁掗⦠춻锦䎷겲铣굛쮂먲꿡㦺좒轃汁̕뎕갴瓖邻吟㭰戔蟏㳵回㡚钦״脮烮鋉둎邫"6e4b127b:c~

यह ऑनलाइन दुभाषिया में काम करना चाहिए ।

यह काम किस प्रकार करता है

यूनिकोड स्ट्रिंग को धकेलने के बाद स्निपेट

6e4b127b:c~

60000 से बेस 127 तक स्ट्रिंग को परिवर्तित करता है, स्ट्रिंग करता है और परिणाम का मूल्यांकन करता है।

कोड जो निष्पादित किया जाता है वह निम्न है:

"..."          " A binary string of length 42.                                            ";
122b7b         " Convert from base 122 to base 7.                                         ";
"\n *./\|"f=   " Replace each digits with the corresponding character.                    ";
60/~           " Split into chunks of length 60 and dump the resulting array.             ";
               " The stack now contains the rocket's head and a body half.                ";
[_W%[\]_W%]    " Push an array of the body half and the reversed body half, a reversed    ";
               " copy of that array and collect both array into another one.              ";
Nf*Nf+         " Join each array of body halves separating by LFs and append LFs.         ";
ri:I*           " Repeat the resulting array I := int(input()) times.                     ";
I<W%           " Keep the first I bodies and reverse their order.                         ";
\a_@\++        " Prepend and append the rocket head/tail.                                 ";
'+"=*"6*'+N+++ " Push S := '+=*=*=*=*=*=*+\n'.                                            ";
*              " Join the array of parts, separating by S.                                ";

— डेनिस
स्रोत

1

आपको वास्तव में इसे बाइट्स में गिनना चाहिए, गैर?

— क्लाउडीयू

8

@ कलैदु: और मेरे स्कोर को बर्बाद कर दो? : P उत्तर उनकी लंबाई बाइट्स द्वारा डिफ़ॉल्ट रूप से बनाए जाते हैं, लेकिन यह प्रश्न यथासंभव कम वर्णों में कहकर इसे ओवरराइड करता है ।

— डेनिस

10

CJam, 121 बाइट्स

5,{_5\-S*\)_'/*"**"@'\*N}%:A['+"+
"]"=*"6**:Lri:M{M(:M;2,{M+2%:J;3,{:I'|J@2\-'.*I'.*?_J"/\\""\/"?JI)3I-?*\++_+'|N}%}%L}*A

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

STDIN के माध्यम से इनपुट n लेता है ।

मैं बाद में किसी बिंदु पर स्पष्टीकरण जोड़ूंगा। मूल रूप से यह सब बहुत भोली तरह से छोरों का एक गुच्छा है। दो अलग-अलग शरीर के अंगों के बीच वैकल्पिक करने के लिए, मुझे इस हिस्से पर एक नेस्टेड लूप मिला है और एक लूप ओवर 0और 1। तब मैं सिर्फ बाहरी पुनरावृत्ति और आंतरिक एक को जोड़ता हूं, और उनकी समता का उपयोग ऊपर या नीचे की ओर इंगित त्रिकोण के बीच तय करने के लिए करता हूं।

— मार्टिन एंडर
स्रोत

मैं एक मिल गया java.util.NoSuchElementExceptionप्रतिलिपि कोड + चिपकाने (पर इशारा करते हुए Lri)

— Claudiu

@Claudiu क्या आपने "इनपुट" फ़ील्ड में एक पूर्णांक दर्ज किया?

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

अरे हाँ, यह करना होगा!

— क्लाउडी

5

रूबी, 203

n,q=$*[0].to_i,"\\/"
h,r,m=1.upto(5).map{|i|(?/*i+"**"+?\\*i).center 14},?++"=*"*6+?+,3.times.map{|i|?|+?.*i+q*(3-i)+?.*(2*i)+q*(3-i)+?.*i+?|}*"\n"
p=m.reverse.tr q,"/\\"
puts h,([r,m,p,r,p,m]*n)[0,3*n],r,h

Ungolfed

मुझे लगता है कि इस मामले में यह गैर-गोल्फ संस्करण के लिए फायदेमंद है।

n      = $*[0].to_i
head   = 1.upto(5).map { |i| ("/"*i + "**" + "\\"*i).center 14 }
ridge  = "+" + "=*"*6 + "+"
middle = 3.times.map { |i| "|" + "."*i + "\\/"*(3-i) + "."*(2*i) + "\\/"*(3-i) + "."*i + "|" }.join "\n"
piddle = middle.reverse.tr "\\/", "/\\"

puts head
puts ([ridge,middle,piddle,ridge,piddle,middle]*n)[0,3*n]
puts ridge, head

व्याख्या

मुझे संदेह है कि यह कुशल के पास कहीं भी है, लेकिन फिर भी यह मजेदार था।

इनपुट से लिया जाता है ARGV।
hरॉकेट के "सिर" और "पूंछ" में r"लकीरें" शामिल हैं जो रॉकेट के अलग-अलग हिस्सों को अलग करती हैं mऔर रॉकेट pके "शरीर" के ऊपर और नीचे के हिस्से हैं।
Array ["ridge", "top of body", "bottom of body", "ridge", "bottom of body", "top of body"]पहले 3*nतत्वों को लेने और लेने के माध्यम से शरीर का निर्माण साइकिल द्वारा किया जाता है ।
puts यह सुनिश्चित करता है कि सब कुछ अपनी लाइन में हो।

— britishtea
स्रोत

3

पायथन, 120 + 77 + 1 = 198 वर्ण

यह गलत दृष्टिकोण होने के कारण समाप्त हो गया, लेकिन मैंने पहले ही समाप्त कर दिया जब मार्टिन ने अपना उत्तर पोस्ट किया।

H,L,T,B=open("R","rb").read().decode('zip').split("X")
n=input()
for p in[H]+([B,T,L,T,B,L]*n)[:3*n][::-1]+[L,H]:print p

R77 बाइट्स की फ़ाइल (+1 फ़ाइल नाम के लिए) की आवश्यकता होती है, जिसे आप निम्न प्रकार से उत्पन्न कर सकते हैं:

>>> open('R','wb').write('eJxNjMENwDAIA/+ZIm8i4Qm6Bw+PwvDFQRUFydwJwd5VMOO6ILqIRjE+LsEI4zw2fSKJ6Vzpmt4p\ndVlnRikoVWqrK+8s/X1ivozIJuo=\n'.decode('base64'))

— Claudiu
स्रोत

3

जेएस, डब्ल्यूआईपी, 252 बी या 173 चार्ट

यह एक फ़ंक्शन नहीं है, इसलिए आपको शुरुआत में n का मूल्य निर्धारित करना होगा (यहां 3), फिर इसे कंसोल में या नोडजेएस में निष्पादित करें।

यहाँ 252b संस्करण है:

n=3;r=a="     /**01    //**001   ///**0001  ////**00001 /////**00000";b="1+=*=*=*=*=*=*+1";for(c=[d="|0/0/0/0/0/0/|1|.0/0/..0/0/.|1|..0/....0/..|",d.split("").reverse().join("")];n--;)r+=b+c[n%2]+1+c[1-n%2];(r+b+a).replace(/0/g,"\\").replace(/1/g,"\n")

और यहाँ 173 वर्ण संस्करण ( http://xem.github.io/obfuscatweet/ का उपयोग करके ) है

n=3;eval(unescape(escape('𬠽𨐽𘠠𘀠𘀠𛰪𚠰𜐠𘀠𘀯𛰪𚠰𜀱𘀠𘀯𛰯𚠪𜀰𜀱𘀠𛰯𛰯𚠪𜀰𜀰𜐠𛰯𛰯𛰪𚠰𜀰𜀰𘠻𨠽𘠱𚰽𚠽𚠽𚠽𚠽𚠽𚠫𜐢𞱦𫱲𚁣👛𩀽𘡼𜀯𜀯𜀯𜀯𜀯𜀯𯀱𯀮𜀯𜀯𛠮𜀯𜀯𛡼𜑼𛠮𜀯𛠮𛠮𜀯𛠮𯀢𛁤𛡳𬁬𪑴𚀢𘠩𛡲𩑶𩑲𬱥𚀩𛡪𫱩𫠨𘠢𚑝𞱮𛐭𞰩𬠫👢𚱣𦱮𙐲𧐫𜐫𨱛𜐭𫠥𜡝𞰨𬠫𨠫𨐩𛡲𩑰𫁡𨱥𚀯𜀯𩰬𘡜𧀢𚐮𬡥𬁬𨑣𩐨𛰱𛱧𛀢𧁮𘠩').replace(/uD./g,'')))

— XEM
स्रोत

कंसोल में परीक्षण किया गया। कूल और +1, लेकिन आमतौर पर जब ओपी आउटपुट मांगता है और न सिर्फ रिटर्न वैल्यू, आउटपुट स्टेटमेंट मांगा जाता है (जैसे कंसोल.लॉग या अलर्ट - मुझे नोडजेएस में पता नहीं है)।

— edc65

आप सही हैं ... मैंने खुद को कंसोल को आउटपुट के रूप में विचार करने की अनुमति दी। : p (भी, नोडजेएस केवल इसके कंसोल afaik पर आउटपुट कर सकता है)

— xem

3

जावास्क्रिप्ट (E6) 252 257

String.repeat का अति प्रयोग

F=p=>{
  R=(n,s='.',a='')=>a+s.repeat(n)+a;
  for(i=f=o=m=n='';++i<6;)
    o+=f+R(6-i,' ')+R(i,u='/')+'**'+R(i,t='\\'),
    f='\n',
    i<4?m+=f+R(2,R(4-i,t+u,R(i-1)),'|',n+=f+R(2,R(i,u+t,R(3-i)),'|')):0;
  s=f+R(6,'=*','+'),
  console.log(o+s+R(p&1,q=m+n+s)+R(p/2,n+m+s+q)+f+o)
}

— edc65
स्रोत

यह मजेदार है, हम दोनों के पास 252 बी है लेकिन पूरी तरह से अलग दृष्टिकोण के साथ :)

— xem

3

जावास्क्रिप्ट (ES3): 243 219 बाइट्स

R=function(n){for(a='',i=5;i--;t=a+=s+'\n')for(s='**',j=6;j--;b=['|../\\..|./\\/\\.|/\\/\\/\\','|\\/\\/\\/|.\\/\\/.|..\\/..'])s=i<j?'/'+s+'\\':' '+s+' ';for(;a+='+=*=*=*=*=*=*+\n',n;)a+=(b[n&1]+b[--n&1]).replace(/[^|]+/g,'$&$&|\n');return a+t}

— subzey
स्रोत

1:, SyntaxError: function statement requires a name2: गलत आउटपुट, बॉडी सेगमेंट सभी समान नहीं होते (विषम और यहां तक कि अलग होते हैं)