ASCII कला में एक क्यूब खींचना

Question

कार्य विवरण:

मोटे तौर पर एक कैबिनेट प्रक्षेपण में ASCII कला में एक घन ड्रा।

Monospaced fontsअक्सर ऐसे पात्र होते हैं जो लगभग दो गुना ऊंचे होते हैं और वे चौड़े होते हैं। चूंकि इनपुट ऊर्ध्वाधर रेखाओं (कोनों को छोड़कर) की लंबाई है, क्षैतिज रेखाएं कई वर्णों के साथ दो बार खींची जाती हैं ताकि परिणामस्वरूप छवि वास्तव में एक घन हो। एक कैबिनेट प्रोजेक्शन द्वारा आवर्ती लाइनों को आधी लंबाई पर खींचा जाता है।

घन के कोनों का प्रतिनिधित्व +, क्षैतिज रेखाओं द्वारा -, ऊर्ध्वाधर रेखाओं द्वारा |और तिरछे लोगों द्वारा किया जाता है /।

सारांश: इनपुट n होने दें , फिर

• क्यूब का एक क्षैतिज किनारा खींचा जाता है -और इसमें 2 n अक्षर होते हैं  ।
• क्यूब के एक ऊर्ध्वाधर किनारे के साथ खींचा जाता है |और इसमें एन अक्षर होते हैं ।
• क्यूब का एक विकर्ण किनारे खींचा जाता है /और इसमें ⁿ / ₂ अक्षर होते हैं ।
• क्यूब के कोनों के साथ खींचा जाता है +। कोनों को एक किनारे की लंबाई के लिए नहीं गिना जाता है जैसा कि ऊपर विस्तृत है (नीचे उदाहरण देखें)।

इनपुट:

इनपुट, मानक इनपुट पर दिया गया, एक धनात्मक है, सम संख्या n (2 ≤ n ) 30) जो घन की लंबवत रेखाओं की लंबाई देता है। इसके बाद सिंगल लाइन ब्रेक होता है।

आउटपुट:

आउटपुट नियमों के ऊपर मानक आउटपुट पर एक क्यूब है। तर्ज पर व्हॉट्सएप को नजरअंदाज किया जाता है।

नमूना इनपुट 1:

2

नमूना आउटपुट 1:

  +----+
 /    /|
+----+ |
|    | +
|    |/
+----+

नमूना इनपुट 2:

4

नमूना उत्पादन 2:

   +--------+
  /        /|
 /        / |
+--------+  |
|        |  |
|        |  +
|        | /
|        |/
+--------+

ETA: मैंने अब सबसे छोटा समाधान स्वीकार कर लिया है। जब छोटा व्यक्ति साथ आएगा तो मैं स्वीकृत उत्तर को अपडेट करूंगा।

चूंकि कुछ लोगों ने पूछा कि हमारे प्रतियोगियों की प्रविष्टियां कब तक थीं:

227 - पायथन
240 - पर्ल
310 - सी
315 - सी
326 - वीबी.नेट
459 - सी

साथ ही हमारे अपने समाधान (दूसरों के साथ रैंक नहीं):

140 - Golfscript
172 - रूबी
183 - PowerShell

Comments

क्या आप सबसे अच्छे समाधानों के बारे में बता सकते हैं? सबसे छोटे कितने वर्ण थे?

— जुआन

@ जुआन: अनुरोधित जानकारी जोड़ी गई

— जॉय

पर्याप्त रूप से, C ++ समान आकृतियों का

— डॉ। रीबमु

@ खुश: हाँ, यह एक अच्छा था, अगर थोड़ी बुराई;;

— जॉय

Answer 1

गोल्फस्क्रिप्ट - 96 वर्ण

~:<2/:$){' '*}:s~'++'<'--'**:^n$,{.$\-s'//'2s<*:&*@s'|':|n}%^$[$s|n|&|]*$s'+'n$,{n'/'@s|&|}%-1%^

कॉम्पैक्टनेस का अधिकांश हिस्सा आक्रामक रूप से लगभग हर चीज को एक चर में रखने से आता है (जब तक कि आपको गोल्फस्क्रिप्ट में लिखा जाना शामिल नहीं है)।

<    n
$    n/2
s    {' '*}     # top of the stack becomes a string of that many spaces
^    '+------+'
&    '      '   # 2n spaces, i.e. 2s<* or <s2*
|    '|'

यहाँ अन्य छोटे-छोटे टोटके।

1. 'LR''str'*-> 'LstrR'।
2. चूंकि हमें अंतिम सरणी में लाइनों के क्रम को उलटने की आवश्यकता है, इसलिए हम पहले के बजाय पाठ को उत्पन्न करने के बाद ऐसा करने का विकल्प चुनते हैं। यह हमें एक चरित्र को बचाने की अनुमति देता है क्योंकि 3 से पहले के बजाय रिक्त स्थान '/'को दो स्टैक तत्वों ( @) से पहले जाने की आवश्यकता होती है @ .. \।

Answer 2

पायथन - 248 243 230 227 191

थोड़ा गन्दा लेकिन यह मूल रूप से लाइन द्वारा क्यूब लाइन (एक स्ट्रिंग बफर का उपयोग करके) प्रिंट करता है।

t=v=h=input()/2
s,p,b,f,n=" +|/\n"
l=p+"-"*t*4+p;S=s*4*t;k=s*h;K=b+S+b
r=s*t+s+l+n
while t:r+=s*t+f+S+f+s*(h-t)+b+n;t-=1
r+=l+k+b+n+(K+k+b+n)*(v-1)+K+k+p+n
while v:v-=1;r+=K+s*v+f+n
print r+l

पहली लाइन की ओर इशारा करने के लिए @ उमरोग, दूसरी लाइन को इंगित करने के लिए @ थोमसो और @ जुआन को मुझे एहसास कराने के लिए कि मैं लाइनों को जोड़ सकता हूं।

Comments

कुछ और स्थान परिवर्तन को बचाने के s=" ";p="+";b="|";f="/";n="\n"लिए s,p,b,f,n=" +|/\n"।

— थॉमस ओ

एक अप वोट काफी नहीं है। आप मुझे अपने समाधान को बेहतर बनाने के लिए जोर दे रहे हैं कि मैंने असंभव सोचा था, धन्यवाद: D

— जुआन

:) अब देखना है कि क्या बेहतर संभव है।

— JPvdMerwe

Answer 3

अजगर - 179

h=input()*2
j=d=h/4
q,e,u,p,k="| \n+/"
w=e*d
s=p+'-'*h+p
i=''
o=e+w+s+u
v=q+e*h+q
while j:o+=e*j+k+e*h+k+e*(d-j)+q+u;j-=1;i+=v+e*j+k+u
print o+s+w+q+u+(v+w+q+u)*(d-1)+v+w+p+u+i+s

मैं यह नोट करना चाहता हूं कि मैंने JPvdMerwe (एक बार प्रिंट करने के लिए एक स्ट्रिंग का उपयोग करके, और इसके लिए एक-लाइनर जो मुझे नहीं पता था कि पायथन में सही सिंटैक्स था) से लिया।

Comments

पंक्ति 3 अंत में एक 2 को याद कर रही है, जो दुर्भाग्य से, गिनती को 256 तक

— बढ़ाती है।

@JPvdMerwe उफ़, पकड़ने के लिए धन्यवाद!

— जुआन

शायद आप परिणामों को एक स्ट्रिंग में कैशिंग करने की कोशिश कर सकते हैं जैसे मैंने किया और केवल एक बार प्रिंट किया?

— JPvdMerwe

@ जुआन मुझे लगता है कि हमें पोस्ट में पुरानी प्रतियां रखने से बचना चाहिए, जब तक कि दो संस्करण प्रमुख रूप से भिन्न न हों। यदि वे इसे पढ़ना चाहते हैं तो वे संपादित इतिहास में देखने योग्य हैं।

— marcog

अकसर किये गए सवाल के रूप में: मैं अक्सर अपने पदों में एक लंबा इतिहास शामिल करता हूं (  यहां एक उदाहरण था जो शामिल होने के लिए बहुत लंबा था, हालांकि)। यह नहीं जानते कि क्या इस तरह की मददगार होती है, लेकिन यह दूसरों को यह पता लगाने में मदद कर सकती है कि इसे छोटा रखने के लिए क्या तरकीबें इस्तेमाल की गईं। हालांकि मेरे पास इसके लिए एक SVN इतिहास भी है।

— जॉय

Answer 4

फोरट्रान 77 - 484 वर्ण

      program z
      read(*,*) i
      g=f('+- ',i/2+1,i,0)
      do k=1,i/2
         g=f('/ |',i/2-k+1,i,k-1)
      end do
      g=f('+-|',0,i,i/2)
      do k=1,i/2-1
         g=f('| |',0,i,i/2)
      end do
      g=f('| +',0,i,i/2)
      do k=1,i/2
         g=f('| /',0,i,i/2-k)
      end do
      g=f('+- ',0,i,0)
      stop
      end
      real function f(c,l,m,n)
      character c(3)
      write(*,*)(' ',j=1,l),c(1),(c(2),j=1,2*m),c(1),(' ',j=1,n),c(3)
      return
      end

"अनबॉस्फेटेड" संस्करण प्रदान करने में कोई वास्तविक बिंदु नहीं है। और ध्यान दें कि मार्कडाउन इंडेंट आवश्यकताओं के साथ अच्छी तरह से नहीं मिलता है।

मैंने writeबयान द्वारा प्रदान की गई छोरों के लिए इनरलाइन की कोशिश की । जाहिर है वे मदद करते हैं लेकिन भाषा के शब्द को मारने के लिए पर्याप्त नहीं जोड़ते हैं। इसे फ्रीफॉर्म इनपुट का उपयोग करके कम किया जा सकता है।

मान्यता:

 $ wc cube_func_array.f
 22  41 484 cube_func_array.f
 $ gfortran cube_func_array.f
 $ echo 2 | ./a.out
   +----+ 
  /    /|
 +----+ |
 |    | +
 |    |/
 +----+ 
 $ echo 4 | ./a.out
    +--------+ 
   /        /|
  /        / |
 +--------+  |
 |        |  |
 |        |  +
 |        | /
 |        |/
 +--------+ 

शुक्र है कि कल्पना यह नहीं कहती कि किस आकार को देखना चाहिए:

 $ echo 1 | ./a.out
  +--+ 
 +--+|
 |  |+
 +--+ 

लेकिन अन्य विषम आकार उचित हैं:

 $ echo 3 | ./a.out
   +------+ 
  /      /|
 +------+ |
 |      | +
 |      |/
 +------+ 

Comments

भाषा का रोचक विकल्प :-)। खैर, आकार 1 बहुत बुरा नहीं लगता है। मेरा समाधान एक अंतहीन लूप फेंकता है। यदि मुझे सही तरीके से याद है (और 80 वर्णों की चौड़ाई में फिटिंग के लिए 30 की ऊपरी सीमा), तो विभिन्न राउंडिंग व्यवहार विषम आकार फेंकने का कारण थे।

— जोए

@joey: मैं समय-समय पर फोरट्रान करता हूं, और अगर मैं विजेता की तुलना में 10 गुना कम कारक हूं तो खुश हूं।

— dmckee

Answer 5

मेरा अपना समाधान, क्योंकि यह पहले ही अजगर द्वारा पीट-पीटकर मार दिया गया है:

विंडोज पॉवरशेल, 183

$t=($w=($s=' ')*($o=($n="$input")/2))*4
$r="|$t|"
$s*($a=$o+1)+($q='+'+'--'*$n+'+')
$o..1|%{$s*--$a+"/$t/$($s*$b++)|"}
"$q$w|"
for(;$o-++$x){"$r$w|"}"$r$w+"
--$b..0|%{$r+$s*$_+'/'}
$q

Comments

आह ... भाषाएं जो आपको एक स्केलर द्वारा "एकाधिक" तार देती हैं, इसके लिए मदद ...

— dmckee

खैर, यह अभी भी वेंटरो की रूबी या गोल्फस्क्रिप्ट से पीछे है - हमेशा की तरह;)

— जॉय

Answer 6

पोस्टस्क्रिप्ट, 237

[/n(%stdin)(r)file token()/p{print}/r{repeat}([){{( )p}r}/N{n 2 mul}(]){n 2 idiv}/l{N(+)p{(-)p}r(+)p}/I{(|)p}/X{][p}>>begin
( )X l()=]-1 1{dup[(/)p N[(/)p]exch sub[(|)=}for
l(|
)X]1 sub{I N[I(|
)X}r
I N[I(+
)X]-1 1{I N[I 1 sub[(/)=}for
l

इतिहास:

• 2011-03-01 01:54 (427) पहला प्रयास।
• 2011-03-01 02:01 (342) def कुछ और चीजें एड करती हैं जो अक्सर दिखाई देती हैं।
• 2011-03-01 02:24 (283) और भी अधिक defएस।
• 2011-03-01 02:42 (281) एक और एक और defदो बाइट्स बचाता है।
• 2011-03-01 03:01 (260) [ और ]चर के रूप में उपयोग किए जाने पर अच्छे गुण हैं :-)। KirarinSnow का शुक्रिया ।
• 2011-03-01 03:12 (246) इनलाइन लाइन टूट जाती है, कई defएस के बजाय एक तानाशाही का उपयोग करते हुए । थैंक्स फिर से :-)।
• 2011-03-01 03:26 (237) अधिक KirarinSnow के लिए धन्यवाद ।

Answer 7

रूबी 1.9, 172 165 है 162 वर्ण

w=(s=?\s)*o=(n=gets.to_i)/2;r=(z=?|)+w*4+z
puts s*(o+1)+q=?++?-*2*n+?+,(l=0...o).map{|u|[s*(o-u),w*4,s*u+z]*?/},q+w+z,[r+w+z]*o-=1,r+w+?+,l.map{|u|r+s*(o-u)+?/},q

Answer 8

रूबी - 423 अक्षर

वास्तव में यह साझा नहीं करना चाहता क्योंकि यह इतनी भयानक गिनती है, लेकिन जब से मैंने लिखा है यह भी हो सकता है।

n=$<.read.to_i
a=(q=Array).new(n+n/2+3){q.new(2*n+n/2+3,' ')<<"\n"}
a[n+1][2*n+n/2+2]=a[0][n/2+1]=a[0][2*n+n/2+1]=a[n/2+1][0]=a[n/2+1][2*n]=a[n+n/2+2][0]=a[n+n/2+2][2*n]=:+
a[0][n/2+2,n*2-1]=a[n/2+1][1,n*2-1]=a[n+n/2+2][1,n*2-1]=[:-]*2*n
a[n/2+2,n].each{|b|b[0]=b[2*n+1]=:|}
a[1,n].each{|b|b[2*n+n/2+2]=:|}
c=n/2
a[1,n/2].each{|b|b[c]=b[2+2*n+c-=1]=:/}
c=n/2
a[n+2,n/2].each{|b|b[2+2*n+c-=1]=:/}
a.flatten.each{|g|print g}

शायद काफी कम हो सकता है, लेकिन मुझे संदेह है कि यह क्रूर-बल दृष्टिकोण एक सभ्य संख्या में पात्रों के पास कहीं भी आने वाला है, इसलिए मुझे परेशान नहीं किया जा सकता है।

Answer 9

PHP, 401 392 382 363 वर्ण:

<? $h=fgets(STDIN);$s="str_repeat";$w=$h*2;$d=$h/2;$b=$h;$c=" ";echo$s($c,$h/2+1)."+".$s("-",$w)."+\n";for($i=1;$i<=$d;$i++,$a=--$b){echo$s($c,($h/2+1)-$i)."/".$s($c,$w)."/".$s($c,$i-1)."|\n";}echo"+".$s("-",$w)."+".$s($c,$d)."|\n";for($i=1;$i<=$h;$i++){echo"|".$s($c,$w)."|";echo $a-->0?$s($c,$b).($a>0?"|":"+")."\n":$s($c,$h-$i)."/\n";}echo"+".$s("-",$w)."+\n";

मैंने मूल रूप से यह देखने के लिए किया था कि मैं पीएचपी में ऐसा करने के लिए कितना कम प्रबंधन कर सकता हूं, क्योंकि मुझे पता था कि यह बहुत लंबा होगा। मुझे यकीन है कि इसे कम किया जा सकता है, लेकिन बहुत विचार करके PHP में कई शॉर्टकट नहीं हैं।

सत्यापन:
http://codepad.viper-7.com/ftYYz9.php53

Ungolfed संस्करण: http://codepad.viper-7.com/4D3kIA

Comments

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

— केविन ब्राउन

कोड को संशोधित किया ताकि वह स्टड से सही ढंग से पढ़े। आकार को कम करने के लिए इसे थोड़ा और गोल किया।

— केविन ब्राउन

निचला दायाँ विकर्ण रेखा नहीं है और इसके बजाय एक ऑफसेट लंबवत रेखा दिखाई देती है। जब तक मैं इसे लागू करने में कुछ गलत नहीं कर रहा हूं, हालांकि।

— जॉय

Answer 10

पर्ल, 163

$d=<>/2;$s=$"x$d;$H=$s x4;$f="|$H|";$t.=$"
x$d--."/$H/".$"x$_."|\n",$m.="$f$s|\n",$b
=$f.$"x$_."/\n$b"for 0..$d-1;$_="+$H+";
y/ /-/;say" $s$_\n$t$_$s|\n$m$f$s+\n$b$_"

पर्ल 5.10 या बाद में, साथ चलाएं perl -E '<code here>'

सम्मानित किया गया संस्करण:

$d = <> / 2;
$s = $" x $d;
$H = $s x 4;
$f = "|$H|";

$t .= $" x $d-- . "/$H/" . $"x$_ . "|\n",
$m .= "$f$s|\n",
$b = $f . $" x $_ . "/\n$b"
  for 0 .. $d-1;

$_ = "+$H+";
y/ /-/;
say " $s$_\n$t$_$s|\n$m$f$s+\n$b$_"

Answer 11

पर्ल, 269 ​​269 262 256 245 244 237 226 228 224 217 चार्ट

उप p {y / xS / + \ //; प्रिंट; y / + \ // xS /} $ b = / 2; $ a = $ b; $ _ = "xx \ n"; s / x /- --- (जबकि ($ a); जब तक (/ ^ S /) {p; s / [xS] / S / g; s / -x / S | /; y / - / / / s / / ? = * S) / - / g; y / S / x /; p; y / -x / | /; p जबकि (- $ b); s / /। / X /; जबकि? (/ \ / /) ) {पी; एस /..ओके / एस /} y / | एस / ++ - /; पी

मूल विचार सब कुछ regex प्रतिस्थापन के साथ करना है। क्योंकि उपयोग किए गए दो अक्षर (+ और /) विशेष वर्ण हैं और रीजैक्स में बहुत अधिक बदल जाते हैं, यह अन्य वर्णों का उपयोग करने और उन्हें प्रिंट करने के लिए प्रतिस्थापित करने के लिए सार्थक है।

थोड़ा अधिक सुपाठ्य संस्करण:

# उपर्युक्त के रूप में स्थानापन्न, मुद्रित और अप्रतिष्ठित करने के लिए सबरूटीन
सब पी {y / xS / + //; प्रिंट; y / + \ // xS /}
# स्टडिन से पढ़ें और प्रारंभिक लाइन सेट करें
$ b = <> / 2; $ a = $ b; $ _ = "xx \ n";
s / x / x ---- / जबकि ($ a--);
# टॉप फेस प्रिंट करें
तक (/ ^ एस /) {
  पी;
  s / [xS] / S / g; # पहली बार दौर: बाएं + -> /; बाद के समय / चाल छोड़ दिया
  एस / -x / एस | /; # केवल प्रासंगिक पहली बार लूप को गोल करें
  y / - / / # केवल प्रासंगिक पहली बार लूप को गोल करें
}
# दूसरी क्षैतिज रेखा वाली रेखा तैयार करें और प्रिंट करें
s / ((= * S) / - / g;
y / एस / एक्स /;
पी;
# अब प्रिंट (n-1) / 2 समान लाइनें
y / -x / | /;
p जबकि (- $ b);
# दाहिने किनारे को अंदर लाएं
रों /.$/ एक्स /;
जबकि (/ \ / /)
{
  पी;
  रों /..$/ एस /
}
# अंतिम पंक्ति
y / | एस / ++ - /;
पी

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

कोई शक नहीं कि कुछ डरावने व्यक्ति इसे बहुत छोटी सीड स्क्रिप्ट में बदल सकते हैं।

Comments

"थोड़ा अधिक सुपाठ्य संस्करण" - यह पसंद होगा कि पर्ल केवल तब ही अधिक पठनीय बन पाता है जब नए अंक और व्हॉट्सएप को शामिल किया जाता है। :)

— स्टीव

@ सच, ​​टिप्पणियों के साथ भी आपको इसे समझने के लिए पर्ल के बारे में थोड़ा जानना होगा। का उपयोग yकरने के लिए trस्पष्ट नहीं है, और जिस तरह के लिए "जबकि" से पहले जा सकते हैं के रूप में या के बाद ...

— पीटर टेलर

Answer 12

लुआ, 294 302 292 बाइट्स

golfed:

n=(...)p="+"d=2*n s=" "S=s:rep(d)h=n/2 T=s:rep(h)L="\n"o="/"v="|"a=p..("-"):rep(d)..p r=T..s..a..L for i=0,h-1 do r=r..s:rep(h-i)..o..S..o..s:rep(i)..v..L end r=r..a..T..v for i=1,h do r=r..L..v..S..v..T..(i==h and p or v) end for i=h-1,0,-1 do r=r..L..v..S..v..s:rep(i)..o end print(r..L..a)

Ungolfed:

n        = n or io.read() or 6
plus     = "+"
doubled  = 2*n
space    = " "
Space    = space:rep(doubled)
halved   = n/2
T        = space:rep(halved)
Line     = "\n"
or_sign  = "/"
vertical = "|"
a        = plus..("-"):rep(doubled)..plus
result   = T..space..a..Line

for i=0,halved-1 do
    result = result .. space:rep(halved-i) .. or_sign .. Space .. or_sign .. space:rep(i) .. vertical .. Line
end

result = result..a..T..vertical

for i=1,halved do
    result = result .. Line .. vertical .. Space .. vertical .. T .. (i==halved and plus or vertical)
end

for i=halved-1,0,-1 do
    result = result .. Line .. vertical .. Space .. vertical .. space:rep(i) .. or_sign
end

print(result .. Line .. a)

Comments

इनपुट मानक इनपुट स्ट्रीम पर दिया गया है। यह यहाँ काम करने के लिए प्रतीत नहीं होता है।

— जॉय

आप कॉल के or 6बाद भी बाहर निकल सकते हैं read(), जिससे चार बाइट्स बचती हैं :-)

— जॉय

एचएम, अब इसके साथ (...)मेरे लिए लुआ 5.1.4 पर कोई काम नहीं करता है।

— जोए

Answer 13

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

╴»
±╵⁷／╋╴«３＋⁷
-×+×║⌐１╴├╋；⁷├⁷±╋２⁷⁸⁸├⁷／╋１２╴«├２⁷５×３＋⁷±╵⁰２ｎ｛┤╴|＊+∔╋

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