मुझे एक पिरामिड बनाएँ

Question

आपको क्यूब्स से एक पिरामिड बनाने की आवश्यकता है। क्यूब्स को 2 कोणों से देखा जा सकता है:

  _____        _____
 /\    \      /    /\
/  \____\    /____/  \
\  /    /    \    \  /
 \/____/      \____\/

यह 2 संभव कोणों से 2-आकार के क्यूब्स के लिए एक उदाहरण है। क्यूब्स की ऊंचाई $sizeस्लैश (या बैक-स्लैश) है, और क्यूब की चौड़ाई 2 * $sizeअंडरस्कोर है। शीर्ष स्तर की चौड़ाई में एक अतिरिक्त अंडरस्कोर वर्ण होना चाहिए।

इनपुट को एक स्ट्रिंग के रूप में प्रदान किया जाएगा जिसमें एक संख्या (क्यूब्स का आकार), स्लैश या बैकस्लैश (दिशा / कोण को इंगित करने के लिए), और एक अन्य संख्या (पिरामिड की ऊंचाई) होगी।

उदाहरण:

इनपुट:

1/1

आउटपुट:

 ___
/\__\
\/__/

इनपुट:

1\1

आउटपुट:

 ___
/__/\
\__\/

इनपुट:

2/1

आउटपुट:

  _____
 /\    \
/  \____\
\  /    /
 \/____/

इनपुट:

1/2

आउटपुट:

     ___ 
 ___/\__\
/\__\/__/
\/__/\__\
    \/__/

इनपुट:

2\2

आउटपुट:

  _____          
 /    /\         
/____/  \_____   
\    \  /    /\ 
 \____\/____/  \ 
 /    /\    \  /
/____/  \____\/ 
\    \  /        
 \____\/        

इनपुट:

1/3

आउटपुट:

         ___  
     ___/\__\
 ___/\__\/__/
/\__\/__/\__\
\/__/\__\/__/
    \/__/\__\
        \/__/

• ट्रेलिंग / अग्रणी व्हाट्सएप ठीक हैं।
• मानक खामियों को अस्वीकार कर दिया जाता है।
• आप मान सकते हैं कि इनपुट हमेशा मान्य होगा।
• आप मान सकते हैं कि इनपुट बहुत बड़े आउटपुट का कारण नहीं बनेगा, अर्थात: जब टर्मिनल पर प्रिंट किया जाता है तो कोई लाइन रैपिंग नहीं होती है।
• पिरामिड का आकार और पिरामिड की ऊंचाई सकारात्मक है (यानी) 1)
• यह कोड-गोल्फ है, इसलिए बाइट्स जीत में सबसे छोटा कोड है।

वर्तमान विजेता है:

जूलिया में 270 बाइट्स के साथ ग्लेन ओ

चुनौती खुली रहती है। यदि आप वर्तमान को हरा देते हैं, तो मैं स्वीकृत उत्तर को अपडेट करूंगा।

Comments

आपकी क्यूब्स हाल की डायमंड पैटर्न चुनौतियों में लोगों से अलग हैं, जिसमें शीर्ष पंक्ति में 2s + 1 अंडरस्कोर हैं, अन्य चुनौतियों में शीर्ष पंक्ति पर 2s अंडरस्कोर और अन्य पंक्तियों पर 2s-1 हैं। इसका मतलब है कि आपकी क्षैतिज पिच 3s + 1 है। मुझे लगता है कि चीजों को मिलाना अच्छा है। किसी को याद करने की स्थिति में बस अवलोकन करना।

— लेवल रिवर सेंट

आकार और ऊंचाई के अधिकतम मूल्य क्या हैं? क्या हम मान सकते हैं कि वे एक अंक के हैं?

— लेवल रिवर सेंट

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

— गिलेड होच

Answer 1

जूलिया - 503 455 369 346 313 270 बाइट्स

f=A->(t=47∉A;h='/'+45t;(m,n)=int(split(A,h));W=2m*n+1;X=(l=3m+1)n+m+1;s=fill(' ',X,W);s[end,:]=10;for i=1:n,j=i:n,M=1:m s[M+i*l+[[L=[J=(2j-i)m,J,J-m]+M W-L]X.-[l,m,0] [0 m].+[1,m,m].+[J,J+m,J-m]X-l]]=[1,1,1]*[h 139-h 95 s[i*l,i*m-m+1]=95]end;print((t?s:flipud(s))...))

Ungolfed:

function f(A)
  t=47∉A      # Determine if '/' is in A ('/' = char(47))
  h='/'+45t   # Set h to the appropriate slash ('\\' = char(92), 92=47+45)
  (m,n)=int(split(A,h)) # Get the two integers from A
  W=2m*n+1    # Get number of rows of output (vertical height of pyramid)
  X=(l=3m+1)n+m+1 # Get columns of output + 1 (for newlines)
  s=fill(' ',X,W) # Create 'canvas' of size X x W
  s[end,:]=10 # Put newlines at end of each output row
  for i=1:n, j=i:n, M=1:m
    # This is where the fun happens.
    # K and L represent the shifting points for '/' and '\\' in the
    # horizontal and vertical directions.
    # They are used to make the code neater (and shorter).
    K=M+i*l-[l,m,0]
    L=[J,J,J-m]+M
    # The next two assign the slashes to appropriate places
    s[K+L*X]=h
    s[K+(W-L)X]=139-h
    # This one puts the first 2m underscores in each of the underscore sets
    s[M+i*l-l+[0 m].+[1,m,m].+[J,J+m,J-m]X]=95
    # This places the final underscores on the top edges (repeatedly)
    s[i*l,i*m-m+1]=95
  end
  # The above produces the array orientation for backslash, but uses
  # the "wrong" slashes along the diagonals if there's a forward slash.
  # This line flips the matrix in that case, before printing it.
  print((t?s:flipud(s))...))
end

उपयोग:

f("3/2")

या

f("2\\3")

Answer 2

पर्ल, 343 बाइट्स

$_=<>;$_=~/(\d+)(\S)(\d+)/;$v=$2eq'/';$w=$1*3+1;for$y(0..$1*2*$3){$k=$w*$3+$1-1;for$z(0..$k){$x=$v?$k-$z:$z;$q=($y+$1-1)/$1|0;$r=$x/$w|0;$d=$q+$r&1;$f=($y-1)%$1;$f=$1-$f-1if$d;$g=($x-$f)%$w;$u=$r;$q=2*$3-$q+1,$u++if$q>$3;print(($q>=$r&&$q&&$g==0)||($q>$r&&$g==$w-$1)?$d^$v?'/':'\\':$q>=$u&&$y%$1==0&&$g>0&&$g<($w-$1+($q==$r))?"_":$")}print$/}

टिप्पणियों के साथ बहुस्तरीय:

$_=<>;$_=~/(\d+)(\S)(\d+)/;$v=$2eq'/'; # read input
$w=$1*3+1; # compute width of each cube in chars
for$y(0..$1*2*$3){$k=$w*$3+$1-1;for$z(0..$k){ # iterate over rows, columns
    $x=$v?$k-$z:$z;   # flip x co-ordinate based on 2nd param
    $q=($y+$1-1)/$1|0;$r=$x/$w|0;   # parallelogram row and column index
    $d=$q+$r&1;  # flag parallelogram as left or right leaning
    $f=($y-1)%$1;$f=$1-$f-1if$d;  # compute a zig-zag offset
    $g=($x-$f)%$w;  # compute column position, offset by zig-zag
    $u=$r;$q=2*$3-$q+1,$u++if$q>$3; # vertical threshold for printing chars   
    print(($q>=$r&&$q&&$g==0)||($q>$r&&$g==$w-$1)?$d^$v?'/':'\\': # output slash
    $q>=$u&&$y%$1==0&&$g>0&&$g<($w-$1+($q==$r))?"_":$") # underscore or space
}print$/}   # print out newline at end of row

उदाहरण आउटपुट:

2/3
                _____  
               /\    \ 
         _____/  \____\
        /\    \  /    /
  _____/  \____\/____/ 
 /\    \  /    /\    \ 
/  \____\/____/  \____\
\  /    /\    \  /    /
 \/____/  \____\/____/ 
       \  /    /\    \ 
        \/____/  \____\
              \  /    /
               \/____/ 

मैंने एक ही एल्गोरिथ्म का उपयोग करके सी फ़ंक्शन के रूप में इसे लागू करने की कोशिश की, एकल-वर्ण चर नामों के लक्जरी से बाइट्स को बचाने की उम्मीद है, लेकिन यह 358 बाइट्स में 15 बाइट्स बड़ा हो गया, -std=c89बंद करने के लिए gcc के तहत संकलित करने की आवश्यकता है voidसमारोह शीर्षक में):

j(char*s){int c,p,v,x,y,k,z,u,g,w,r,d,q,f;char e;sscanf(s,"%d%c%d",&c,&e,&p);v=e=='/';w=c*3+1;for(y=0;y<=c*2*p;y++){k=w*p+c-1;for(z=0;z<=k;z++){x=v?k-z:z;q=(y+c-1)/c;r=x/w;d=q+r&1;f=(y+c-1)%c;if(d)f=c-f-1;g=(x-f)%w;u=r;if(q>p){q=2*p-q+1;u++;}printf("%c",(q>=r&&q&&g==0)||(q>r&&g==w-c)?d^v?'/':'\\':q>=u&&y%c==0&&g>0&&g<(w-c+(q==r))?'_':' ');}printf("\n");}}

Comments

आपको सबसे अधिक प्राप्त करने में सक्षम होना चाहिए, यदि सभी 15 बाइट्स सी संस्करण पर वापस नहीं आते हैं: printf("%c" --> putchar(,, printf("\n") --> puts("")फ़ंक्शन के बाहर सभी अंतर घोषणाओं को स्थानांतरित करें, तो आप इसे समाप्त कर सकते int हैं (देखें meta.codegolf.stackexchange.com/q/5532-15599 ), अपने ascii कोड के लिए सभी चरित्र शाब्दिक बदलें ' ' --> 32। अपने छोरों जैसे उदाहरण के लिए for(k+1;z--;)भी मदद कर सकता है, लेकिन मुश्किल है।

— लेवल रिवर सेंट

इसके अलावा, मुझे लगता है कि eयह एक ऐसा उदाहरण हो सकता है जो आपको शून्य पर आरंभीकृत करता है। sscanf केवल सबसे कम महत्व वाली बाइट को अधिलेखित करेगा और अन्य तीन बाइट्स में कोई भी मौजूदा कचरा छोड़ सकता है।

— लेवल रिवर सेंट

अंत में मुझे लगता है कि एक पूरा कार्यक्रम इस मामले में एक समारोह से बेहतर होगा। आप mainइसके बजाय तीन अतिरिक्त वर्ण प्राप्त करते हैं, jलेकिन आपको पैरामीटर को पास नहीं करना पड़ता है s, और आप वैश्विक चरों के स्वत: आरंभ का लाभ उठा सकते हैं।

— लेवल रिवर सेंट

Answer 3

रूबी, 332

अब तक की गई एकमात्र गोल्फिंग टिप्पणियों और इंडेंट का उन्मूलन है। मैं बाद में गोल्फ करूंगा।

gets.match(/\D/)
d=$&<=>"@"
n=$`.to_i
m=2*n
p=$'.to_i
a=(0..h=4*n*p).map{' '*h*2}
(p*p).times{|j|
x=h-j/p*(3*n+1)*d
y=h/2+(j/p-j%p*2)*n
if j%p<=j/p
(-n).upto(n){|i|
a[y+i][i>0?x+m+1-i :x-m-i]=?/
a[y+i][i>0?x-m-1+i :x+m+i]='\\'
a[y+n][x+i]=a[y-n][x+i]=a[y][x-d*(n+i-1)]=?_
a[y+i+(i>>9&1)][x+d*i.abs]='\_/'[(0<=>i*d)+1]
}
end
}
puts a

मैंने रिक्त स्थान की एक सरणी स्थापित की और इसमें व्यक्तिगत पात्रों को पोक किया। अतिरिक्त कोड से बचने के लिए, दूसरे के ऊपर (नीचे से ऊपर तक) और क्यूब के भीतर एक ही क्यूब के दोनों को बहुत अधिक ओवरराइड करना होता है। मैं एक लयबद्ध रेखाचित्र ( /codegolf//a/54297/15599 के समान ) बनाकर पिरामिड बनाता हूं और शीर्ष आधे की ओर बढ़ता है।

कठोर भाग स्केलेबल क्यूब खींच रहा था। मैंने _क्षैतिज पक्षों पर 2n + 1 वर्णों के साथ एक परिधि षट्भुज के साथ शुरुआत की । मेरे पास 2n + 1 भी था /और \इसलिए मेरे पास एक भी बहुत सारे थे, लेकिन _अंतिम की साजिश रचकर मैंने उन्हें अधिलेखित कर दिया।

आंतरिक रेखाएं केवल वही होती हैं जो क्यूब का सामना कर रही दिशा के आधार पर बदल जाती हैं। मैं सभी /और \एक ही काम के साथ साजिश रचता हूं । absदिशा को उलटने में मदद करता है, और i>>9&1i के नकारात्मक मानों में एक अतिरिक्त 1 जोड़ता है, जो शीर्ष भाग को नीचे करता है। के लिए i= 0 आवश्यक में से _एक को ओवरप्लेट किया गया है, इसलिए चयनकर्ता स्ट्रिंग '\_/'में सभी तीन प्रतीकों शामिल हैं, जिन्हें साइन के अनुसार चुना गया है i।

आउटपुट के चारों ओर व्हाट्सएप पर्याप्त है लेकिन अत्यधिक नहीं: 4 * p * n उच्च और 8 * p * n चौड़ा (बाद वाला शीर्ष क्यूब को हमेशा आउटपुट के केंद्र में सक्षम करने के लिए है।) मैं समझता हूं कि "पीछे चल रहा है" अग्रणी है। व्हॉट्सएप "में पूरी लाइनें शामिल हैं, लेकिन यदि आवश्यक हो तो संशोधित कर सकते हैं।

अघोषित कोड

gets.match(/\D/)                                   #find the symbol that is not a digit. it can be extracted from $&
d=$&<=>"@"                                         #direction, -1 or 1 depends if ascii code for symbol is before or after "@"
n=$`.to_i                                          #side length extracted from match variable $`
m=2*n
p=$'.to_i                                          #pyramid height extracted from match variable $'
a=(0..h=4*n*p).map{' '*h*2}                        #setup an array of h strings of h*2 spaces

(p*p).times{|j|                                    #iterate p**2 times
  x=h-j/p*(3*n+1)*d                                #calculate x and y coordinates for each cube, in a rhombus
  y=h/2+(j/p-j%p*2)*n                              #x extends outwards (and downwards) from the centre, y extends upwards 

  if j%p<=j/p                                      #only print the bottom half of the rhombus, where cube y <= cube x  
    (-n).upto(n){|i|                               #loop 2n+1 times, centred on the centre of the cube 
      a[y+i][i>0?x+m+1-i :x-m-i]=?/                #put the / on the perimeter of the hexagon into the array          
      a[y+i][i>0?x-m-1+i :x+m+i]='\\'              #and the \ also.
      a[y+n][x+i]=a[y-n][x+i]=a[y][x-d*(n+i-1)]=?_ #plot all three lines of _ overwriting the / and \ on the top line    
      a[y+i+(i>>9&1)][x+d*i.abs]='\_/'[(0<=>i*d)+1]#plot the internal / and \ overwriting unwanted _
    }
  end
}
puts a