पूर्ववर्ती पूर्ण असिसी क्यूब्स

Question

पहला पूर्ववर्ती पूरा असिसी क्यूब (पीएसी 1) साइड लंबाई 1 के साथ एक सरल घन है और इस तरह दिखता है:

 /////\
/////  \
\\\\\  /
 \\\\\/

पीएसी 2 एक ज्यामितीय आकार ऐसा है कि अपने पूर्ववर्ती (के साथ संयोजित पीएसी 1 ) एक ओर लंबाई पूरा करता है 2 घन:

      front                back
   /////////\           /////////\
  /////////  \         /////////  \
 /////\\\\\   \       /////////    \
/////  \\\\\   \     /////////      \
\\\\\  /////   /     \\\\\\\\\      /
 \\\\\/////   /       \\\\\\\\\    /
  \\\\\\\\\  /         \\\\\\\\\  /
   \\\\\\\\\/           \\\\\\\\\/

क्योंकि बैक- व्यू एक तरह का बोरिंग है, हम केवल सामने वाले की रुचि रखते हैं ।

वही पीएसी 3 के लिए जाता है : कुछ दृश्य सोच के साथ पीएसी 2 को घेर लिया जा सकता है और पीएसी 3 में प्लग किया जा सकता है ताकि एक ठोस पक्ष की लंबाई 3 घन बन सके:

     /////////////\
    /////////////  \
   /////\\\\\\\\\   \
  /////  \\\\\\\\\   \
 /////   /////\\\\\   \
/////   /////  \\\\\   \
\\\\\   \\\\\  /////   /
 \\\\\   \\\\\/////   /
  \\\\\  /////////   /
   \\\\\/////////   /
    \\\\\\\\\\\\\  /
     \\\\\\\\\\\\\/

और इसी तरह पीएसी 4 के साथ :

       /////////////////\
      /////////////////  \
     /////\\\\\\\\\\\\\   \
    /////  \\\\\\\\\\\\\   \
   /////   /////////\\\\\   \
  /////   /////////  \\\\\   \
 /////   /////\\\\\   \\\\\   \
/////   /////  \\\\\   \\\\\   \
\\\\\   \\\\\  /////   /////   /
 \\\\\   \\\\\/////   /////   / 
  \\\\\   \\\\\\\\\  /////   /
   \\\\\   \\\\\\\\\/////   /
    \\\\\  /////////////   /
     \\\\\/////////////   /
      \\\\\\\\\\\\\\\\\  /
       \\\\\\\\\\\\\\\\\/

कार्य:

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

यह कोड-गोल्फ है , इसलिए अपनी पसंद की भाषा में यथासंभव कम बाइट्स का उपयोग करने का प्रयास करें।

Comments

क्या बाद में उल्टे आउटपुट, यानी बाएँ और दाएँ स्विच करना ठीक है?

— बुसुकुआन

नहीं, यह "लाइटिंग" को लगातार बनाए रखने की चुनौती का हिस्सा है।

— लकोनी

आमतौर पर कोड-गोल्फ सवालों के लिए इनाम प्रतियोगिता को प्रोत्साहित करने और उत्तरों को हासिल करने के लिए सबसे कम उत्तर में जाता है, लेकिन यह वास्तव में लागू नहीं किया जा सकता है, और आप इसे किसी भी जवाब देने के लिए स्वागत से अधिक हैं जो इसके हकदार हैं।

— mbomb007

Answer 1

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

f=
(n,l=n*4+1,r=1,i=n*2,g=a=>` / \\ /
`.replace(/./g,c=>c.repeat(a.pop())))=>n?g([r,,l,--i])+g([r,2,l,--i])+f(n-1,l-1?1:r-4,r-1?1:l-4).replace(/(\S).*(.)/g,r-1?`$1   $&$2$2$2$2`:`$1$1$1$1$&   $2`)+g([r,2,l,,,i])+g([r,,l,,,i+1]):``

<input type=number min=0 oninput=o.textContent=f(+this.value)><pre id=o>

Answer 2

बैच, 559 432 400 बाइट्स

@echo off
set m=
for /l %%i in (1,1,%1)do call set m=  %%m%%
call:c "%m:~2%" %m: =//%/\
exit/b
:c
setlocal
set m=%~1%2%~3
echo  %m%
echo %m:/\=/  \%
set s=%~1
if "%s:~,1%"=="/" goto g
set t=%2
set t=%t:~3,-3%
if %t:~,1%==/ (call:c "%s:~2%////" /\%t:/=\% "   \%~3")else call:c "%s:~2%/   " %t:\=/%/\ "\\\\%~3"
:g
set m=%m:/=-%
set m=%m:\=/%
set m=%m:-=\%
echo %m:\/=\  /%
echo  %m%

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

1       12/////////////////\233
1      12/////////////////  \233
1     ////12/\\\\\\\\\\\\\23   \3
1    ////12/  \\\\\\\\\\\\\23   \3
1   /////   12/////////\23\\\\   \3
1  /////   12/////////  \23\\\\   \3
1 /////   ////12/\\\\\23   \\\\\   \3
1/////   ////12/  \\\\\23   \\\\\   \3

1. इंडेंटेशन (जो हर पंक्ति को कम करता है) और बाएं त्रिकोण, जो हर दूसरी पंक्ति को बढ़ाता है
2. मध्यम सिकुड़ता त्रिकोण, हर दूसरी पंक्ति में वैकल्पिक पक्षों पर छोटे त्रिकोण के साथ
3. दायां त्रिभुज, जो बाईं ओर सिंक के साथ बढ़ता है

संपादित करें: कोड में सुधार करके 20% से अधिक की बचत हुई जो ऊपर से नीचे तक परिलक्षित हुई। बाईं दो और मध्य तीन स्ट्रिप्स को मर्ज करके लगभग 10% बचाया।

Answer 3

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

；Ｘø；｛１ｘ／╋
ø╶｛«５⁸２²４×⁸²«１╋²«＼＋；↔５３╋｝═

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

Comments

एसओजीएल के एएससीआईआई कला संस्करण को एसओजीएल ने एएससीआईआई कला चुनौती से बाहर कर दिया था?

— डायलन

@dylnan कैनवस में निर्मित विकर्ण स्थान पूर्व-निर्मित नहीं था, जिसमें यह थोड़ा सा गोल्फ कर सकता था। चुनौती के लिए बिल्ट-इन को जोड़ना सही नहीं

— लगा

समझ गया। बस उत्सुक। अभी भी दो शांत भाषाओं

— dylnan

Answer 4

SOGL V0.12 , 32 बाइट्स

ø.∫4*I└*2∙f«5└*∙+¼F«╝┼;↔±53╬5}╬±

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

सरल व्याख्या:
1. 1.x में से प्रत्येक के लिए iterate
। 2. ⌐की i*4+1ऊँचाई और ऊँचाई = (0-indexed)i // 2
3. के साथ एक आकृति बनाएं ताकि यह ऐसा दिखे जैसे कि ⦧
4. क्षैतिज रूप से एक "\" आकार संलग्न करें
5. पिछला चरण डालें अंदर कि उलट 6. सब कुछ के बाद, खड़ी दर्पण

पूरा कार्यक्रम:

ø                                 push an empty string - starting stage
 .∫                          }    iterate over 1..input
   4*                               multiply the 1-indexed counter by 4
     I                              and add 1
      └*                            repeat "/" that many times
        2∙                          and repeat vertically twice. Top 2 lines are done
          f«                        push the 0-indexed counter floor divided by 2
            5└*                     push "/" repeated 5 times
               ∙                    and repeat that vertically by the result of the "f«"
                +                   add vertically, creating a "⌐" shape
                 ¼                  prepend each next line with one less space than the above
                  F«                push 1-indexed counter floor divided by 2
                    ╝               create a "\" diagonal that long
                     ┼              and append it horizontally. Shell is done of this hexagon
                      ;↔±           get the previous item on the stack and reverse it horizontally
                         53╬5       and at [5;3] insert the previous result in this
                              ╬±  once everything's done, mirror vertically to finish the hexagon

Answer 5

हास्केल , 232 227 224 187 183 180 175 बाइट्स

m '/'='\\'
m '\\'='/'
m c=c
r=reverse
k=map
n?s=('/'<$[1..4*n])++s
f 0=[]
f n=n?"/\\":n?"/  \\":[1?k m(r s)++"   \\"|s<-f$n-1]
s="":k(' ':)s
((++).r<*>k(k m)).zipWith(++)s.r.f

अंतिम पंक्ति में अनाम फ़ंक्शन पूर्णांक तर्क लेता है और उस आकार के घन के लिए मुद्रित की जाने वाली पंक्तियों को पैदावार देता है।

छोटे से बड़े क्यूब्स को आकर्षित करने के लिए पुनरावर्तन का उपयोग करने का विचार है। आकार 1 के एक क्यूब के ऊपरी आधे हिस्से को देखते हैं। फिर हम आकार 2 के एक क्यूब के ऊपरी आधे हिस्से को पूर्व के आधे हिस्से को दिखाते हैं और इसके चारों ओर स्लैश और रिक्त स्थान का एक निश्चित पैटर्न जोड़ते हैं:

                                         ///////// \
                                        ///////// \
     ///// \ ==> / \\\\\ ==> //// / \\\\\    \
    ///// \ / \\\\\ //// / \\\\\    \

तो एल्गोरिथ्म आकार n का घन खींचने के लिए है

1. आकार n-1 के ऊपरी घन आधे के लिए लाइनें प्राप्त करें ।
2. प्रत्येक पंक्ति ( /एस और \एस फ्लिप करके ), और पैड ////और \चारों ओर दर्पण ।
3. पैटर्न ////ⁿ प्लस /\और के साथ दो लाइनों को प्रेपेंड करें / \।
4. पूर्ण घन प्राप्त करने के लिए परिणामी लाइनों को दर्पण करें।
5. उपयुक्त स्थानों के साथ पैड लाइनें।

Comments

अनाम कार्यों की अनुमति है, इसलिए आप ड्रॉप कर सकते हैं g=। (\l->r l++k(k m)l)के रूप में ही है liftM2 (++) r (k(k m)), जो फिर से छोटा किया जा सकता है (++).r<*>k(k m)। इसे ऑनलाइन आज़माएं!

— लकोनी

Answer 6

रूबी , 174 167 169 167 बाइट्स

->n{a=(1..m=n*4).map{' '*m}
(-n..0).map{|i|(-2*i).times{|k|a[y=k+2*j=n+i][m+~k+i*2,2+k*2-s=4*i]=?/*(1-~j%2*s)+'  '*k+?\\*(1-j%2*s)
a[~y]=a[y].tr('/\\','\\\\/')}}
a*$/}

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

n*4रिक्त स्थान से भरे तार की एक सरणी बनाता है , फिर इसे क्रमिक रूप से छोटे क्यूब्स के साथ ओवरराइट करता है।

टिप्पणी कोड

->n{a=(1..m=n*4).map{' '*m}                 #make an array of n*4 strings of n*4 spaces (up to centreline of final output)
  (-n..0).map{|i|                           #iterate through cube sizes from n down to 0 (i is negative -n to 0)
    (-2*i).times{|k|                        #iterate through the number of lines in the top half of the cube
      a[y=k+2*j=n+i][m+~k+i*2,2+k*2-s=4*i]= #overwrite the correct part of the correct line
      ?/*(1-~j%2*s)+'  '*k+?\\*(1-j%2*s)    #with the correct string of the form "/spaces\" with an additional -4*i symbols on one side
      a[~y]=a[y].tr('/\\','\\\\/')          #copy the current line from top half into bottom half, subsituting / for \ and vice versa
    }
  }
a*$/}                                       #return the elements of the array a, concatenated with newlines $/

Answer 7

पायथन 2 , 254 234 226 203 201 199 बाइट्स

अंत में उप 200!

P=[];n=0
M=lambda r:(u''+r).translate({47:92,92:47})
exec r"n+=1;q='/'*4;P=[q*n+'/\\',q*n+'/  \\']+[q+'%s   \\'%M(r[::-1])for r in P];"*input()
print'\n'.join(l.center(8*n)for l in(P+map(M,P[::-1])))

ट्रिक्स:

यह समारोह सभी स्वैप करने के लिए प्रयोग किया जाता है \के साथ /और इसके विपरीत
एक को Python2 में लंबे थोड़ा - साथ यूनिकोड ही काम करता है
बाहर की जाँच करें इस यह कैसे काम करता लिए

M=lambda r:(u''+r).translate({47:92,92:47})

---

प्रत्येक पुनरावृत्ति के
लिए नई शीर्ष दो पंक्तियाँ बनाता है। अब मैं पिछली पुनरावृत्ति से इस पंक्तियों को प्राप्त करने के लिए कॉम्पैक्ट तरीका नहीं खोज सकता

P=[q*n+'/\\',q*n+'/  \\']

---

पिछले पुनरावृत्ति की सभी पंक्तियों को उल्टा करें और स्लैश स्वैप करें

[q+'%s   \\'%M(r[::-1])for r in P]

---

शीर्ष आधा कॉपी करें, पंक्तियों द्वारा उलट, स्वैप स्लैश

P+map(M,P[::-1])

---

सेंटर पेडिंग स्ट्रिंग्स के लिए नीट विधि

l.center(8*n)

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

Answer 8

स्टैक्स , 36 बाइट्स

äª.$u>↓Z╙╝B↨EXª¡╜?Xáhç∙╩p/♂ù⌠r↨c⌐f/*

इसे चलाएं और डीबग करें

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

यहाँ प्रोग्राम अनपैक्ड, अनगुल्फेड और कमेंटेड है।

{               begin block to repeat
  iHYH^H'\*     make a string of '\' characters and set the Y register
                  pseudo-code: push(((y = (i * 2)) * 2 + 1) * 2 * '\')
                  given the 0-based iteration index `i`, let y = 2 * i
                  and push a string consisting of (i*8 + 2) backslashes
  2M            split the string into to equal size (i*4 + 1) substrings
  ~+            push array to input stack and concatenate
                  on the first iteration, this is a no-op
                  subsequently, it prepends the array to the result so far
  {             begin a block to use for mapping
    4'\*+       append 4 backslashes to this element
    :R          "brace-wise" reverse
                  this reverses the string AND the slashes in it
    |YH3+92&    write 92 to index (++y * 2 + 3) in the array
                  this puts the trailing backslash at the correct position
                  this will be an out of bounds index, so the string will grow
                  92 is the character code for backslash 
  m             execute map using block
}*              repeat block specified number of times
|C              vertically center all rows
{               begin block for output mapping
  Q             output this line without popping
  :Rr           "brace-wise" reverse, and then actually reverse
                  net effect is to swap forward and backward slashes
m               execute map using block
rm              reverse array, and output all rows

इसको चलाओ

Answer 9

हास्केल, 193 बाइट्स

विजेता की तुलना में लंबा, लेकिन दृष्टिकोण दिलचस्प हो सकता है - यहां तक ​​कि उपयोग करता है cosऔर pi:)

कोड:

i s e f|max e f>s=""|max e f<s=" "|e==s="\\"|1<2="/"
w n y x=head$do{d<-[1..n];o<-[-2*d..2*d];z<-[(cos(pi*(n-d)))*o+x];i(2*d)(abs$z-y)(abs$z+y-1)}++" "
n!h=h<$>[1-2*n..2*n]
f n=((2*n)!)<$>n!w n

इसे इस तरह चलाएं:

mapM_ putStrLn (f 4)

यह कार्यक्रम मूल रूप से इस तरह के कई हीरे को आकर्षित करता है:

------------------------
------------------------
-----------/\-----------
----------/  \----------
---------/    \---------
--------/      \--------
--------\      /--------
---------\    /---------
----------\  /----------
-----------\/-----------
------------------------
------------------------

फंक्शन i s e f'साइज' का एक डायमंड s, जहां e, fहैं (abs$z-y)(abs$z+y-1)।

फंक्शन सही स्थानों wद्वारा खींचे गए हीरे को स्थानांतरित करता है i। headइसकी परिभाषा में उपयोग केवल सबसे ऊपरी परत को देखने के लिए जिम्मेदार है।

इसे यहाँ आज़माएँ

Comments

हो सकता है कि किसी के पास कोड कम करने के लिए कुछ विचार हों?

— राडेक

Answer 10

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

ＦＮ«↗×⊗⊕ι/↓↘Ｇ↖²→⊕×⁴⊕ι↘²\Ｇ←⁴↘⊕⊗ι→⁴\Ｍ⁴→‖Ｔ»‖Ｍ↓

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

ＦＮ«

क्यूब्स को सबसे छोटे से सबसे बड़े तक खींचें। (सबसे बड़ी से सबसे छोटी रेखा खींचने का मतलब है कि मैंने विषम संख्या के लिए एक दर्पण छवि के साथ समाप्त किया, जिसे ठीक करने के लिए बहुत सारे बाइट्स खर्च होते हैं।)

↗×⊗⊕ι/

की एक लाइन प्रिंट करें /। (यह \दाईं ओर एस बन जाएगा , लेकिन ड्राइंग मिरर किया गया है क्योंकि यह लूप के अंत में मिरर करने के लिए गोल्फर है।)

↓↘Ｇ↖²→⊕×⁴⊕ι↘²\

शीर्ष दो पंक्तियों को मुद्रित करें \। ( \एक बहुभुज में सभी एस को आकर्षित करने का मतलब था कि कर्सर एक अजीब स्थिति में समाप्त हो गया था जिसे ठीक करने के लिए बहुत सारे बाइट्स की लागत है।)

Ｇ←⁴↘⊕⊗ι→⁴\

एस की बाईं चार पंक्तियों को प्रिंट करें \। (पांचवीं पंक्ति पिछली क्यूब से आती है।)

Ｍ⁴→

अगले क्यूब की शुरुआत में जाएं।

‖Ｔ»

अगले क्यूब के लिए क्षैतिज रूप से तैयार परावर्तित करें।

‖Ｍ↓

क्यूब को पूरा करने के लिए सब कुछ लंबवत रूप से मिरर करें।