स्वचालित घर-निर्माता

Question

ऑटोमैटिक हाउस बिल्डिंग नैनोबॉट्स तैयार किए गए हैं, और उन्हें कोड करना आपका काम है।

यहाँ इनपुट द्वारा बनाया गया घर है 7 4 2

  /-----/|
 /     / |
|-----|  |
|     |  |
|     | /
|_____|/

इनपुट एक स्ट्रिंग है जिसमें घर के आयाम होते हैं।

7 चौड़ाई है।

|_____|

---7---

4 ऊँचाई है।

|
|
|
|

2 गहराई है

 / 
/

इस इनपुट को देखते हुए, क्या आप घर बना सकते हैं?

आपका कोड जितना संभव हो उतना छोटा होना चाहिए ताकि वह रोबोट में फिट हो सके।

टिप्पणियाँ

इनपुट के रूप में आपको सबसे छोटे आयाम दिए जाएंगे 3 2 2। आपका प्रोग्राम उन आयामों के साथ कुछ भी कर सकता है जो उससे छोटे हैं3 2 2 ।

परीक्षण के मामलों

3 2 10

          /-/|
         / / |
        / / /
       / / /
      / / /
     / / /
    / / /
   / / /
  / / /
 / / /
|-| /
|_|/

Comments

संबंधित ।

— लीक नून

यह घन नहीं है, इसलिए मुझे लगता है कि मेरा प्रश्न काफी अलग है। हालांकि चर बदल सकता है।

अधिक वृषण कृपया?

— लीक नून

साथ ही, यह एक अच्छा सवाल है। मुझे नहीं लगता कि हमारे पास अभी तक कोई है।

— R

आउटपुट किसके लिए होगा 3 2 10?

— डाउनगेट

Answer 1

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

w,h,d=input();i=d
while-i<h:c='|/'[i>0];print' '*i+c+'- _'[(d>i!=0)+(h+i<2)]*(w-2)+c+' '*min(d-i,h-1,w+1,h-1+i)+'/|'[d-i<h];i-=1

पंक्ति से पंक्ति। पंक्ति सूचकांकों की iगिनती नीचे से dहोती है -h+1।

Comments

आप की जगह 3 बाइट्स ट्रिम कर सकते हैं ' '*min(d-i,h-1,w+1,h-1+i)के साथ(' '*d)[max(0,i):h-1+i]

— RootTwo

Answer 2

रूबी, 145 बाइट्स

तार की सूची लौटाता है। सूची में प्रत्येक तत्व एक पंक्ति से मेल खाता है। यदि एक बहुस्तरीय स्ट्रिंग वापस आनी चाहिए, *$/तो अंतिम ब्रैकेट से ठीक पहले जोड़ने के लिए 3 बाइट्स जोड़ें ।

->w,h,d{s=' ';(0..m=d+h-1).map{|i|(i<d ?s*(d-i)+?/:?|)+(i<1||i==d ??-:i==m ??_ :s)*(w-2)+(i<d ? ?/:?|)+(i<h ?s*[i,d].min+?|:s*[m-i,h-1].min+?/)}}

Answer 3

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

(w,h,d)=>[...Array(d+h--)].map((_,i)=>` `[r=`repeat`](i<d&&d-i)+(c=`|/`[+(i<d)])+` _-`[i&&i-d?h+d-i?0:1:2][r](w-2)+c+` `[r]((i<d?i:d)-(i>h&&i-h))+`|/`[+(i>h)]).join`\n`

जहां \nएक शाब्दिक न्यूलाइन चरित्र का प्रतिनिधित्व करता है। स्पष्टीकरण:

(w,h,d,)=>                          Parameters
[...Array(d+h--)].map((_,i)=>       Loop over total height = d + h
 ` `[r=`repeat`](i<d&&d-i)+         Space before roof (if applicable)
 (c=`|/`[+(i<d)])+                  Left wall/roof edge
 ` _-`[i&&i-d?h+d-i?0:1:2][r](w-2)+ Space, floor or eaves between walls
 c+                                 Right wall/roof edge (same as left)
 ` `[r]((i<d?i:d)-(i>h&&i-h))+      Right wall
 `|/`[+(i>h)]                       Back wall/floor edge
).join`                             Join everything together
`

संपादित करें: @jrich के लिए 2 बाइट्स सहेजे गए

Comments

,r='repeat'सामने से हटाने की कोशिश करें और पहली बार के [r]साथ की जगह[r='repeat']

— 23:16

@jrich धन्यवाद, मेरे पास मूल रूप से था ,r=(n,c=` `)=>c.repeat(n)और जब मैंने व्यवहार बदला तो मैंने पुनर्व्यवस्था की संभावना की अनदेखी की।

— नील

Answer 4

पायथन 224 301 297 बाइट्स

(अब 1x1x1 सहित सभी बॉक्स के लिए काम करता है)

l,w,h=input()
s,r,d,v,R,x=" "," - ","/","|",range,(l*3-1)
print s*(w+1)+r*l
for n in R(w):
    if n<h:e,c=v,n
    else:e,c=d,h
    print s*(w-n)+d+s*x+d+s*c+e
if h-w>=1:e,c=v,w
elif w>h:e,c=d,h
else:e,c=d,w
print s+r*l+s*c+e
for n in R(h):
    if h>w+n:e,c=v,w
    else:e,c=d,h-n-1
    print v+s*x+v+s*c+e
print r*l

स्पष्टीकरण:

तीन स्थिरांक में ले जाता है: एल (लंबाई), एच (ऊंचाई), डब्ल्यू (चौड़ाई)।

यदि हम कुछ नमूने के बक्से को देखते हैं, तो हम रिक्ति में पैटर्न पा सकते हैं।

3 x 4 x 3 बॉक्स के लिए, हम वर्गों के बीच रिक्ति का प्रतिनिधित्व करने के लिए संख्याओं का उपयोग करेंगे।

1234 -  -  - 
123/12345678/|
12/12345678/1|
1/12345678/12|
1 -  -  - 123|
|12345678|123/
|       8|12/
|       8|1/
|       8|/
 -  -  - 

शीर्ष पंक्ति में 4 स्थान हैं या जो w + 1. अगली तीन पंक्तियों में w - (1 * x) है। X रेखा है।

ये ऐसे पैटर्न हैं जो सभी बक्से में सभी लाइनों में जारी रहते हैं। इसलिए, हम इस लाइन को आसानी से लाइन कर सकते हैं, पैटर्न को फिट करने के लिए रिक्त स्थान की संख्या को गुणा कर सकते हैं।

यहां 5 x 5 x2 बॉक्स के लिए एक नमूना है।

 123 -  -  -  -  -
 12/12345678912345/|
 1/              /1|
 1 -  -  -  -  - 12|
 |              |12|
 |              |12|
 |              |12|
 |              |1/
 |12345678912345|/
  -  -  -  -  -

Comments

आपको शायद गोल्फ रखना चाहिए।

— Rɪᴋᴇʀ

इसके अलावा, आपको w,h,l=input()इसे कार्य करने या इसे कार्य करने की आवश्यकता है।

— Rɪᴋᴇʀ

प्रोग्रामिंग पहेलियाँ और कोड गोल्फ में आपका स्वागत है! हमें सभी प्रस्तुतियाँ चाहिए कि या तो पूर्ण कार्यक्रम हों जो STDIN से पढ़ें और STDOUT या फ़ंक्शन को लिखें जो तर्क और रिटर्न मान स्वीकार करते हैं। हमें पोस्टिंग के समय जीतने के लिए गंभीर दावेदार होने के लिए सबमिशन की भी आवश्यकता होती है, जिसका अर्थ है कि हम कोड गोल्फ के लिए अनऑर्गलाइज्ड या आंशिक रूप से अनलॉल्फ़्ड समाधान की अनुमति नहीं देते हैं।

— एलेक्स ए

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

— जेम्स

@DrGreenEggsand HamDDJ ने इसे ठीक किया! यह एच, डब्ल्यू, और एल के एक निश्चित पैटर्न के लिए खाता नहीं था इसलिए मैंने कुछ बयान दिए।

— जोश

Answer 5

पायथन 3.5, 328 326 313 305 295 248 बाइट्स

( तीखे बयानों के आकार को कम करने के बारे में टिप के लिए केविन लाउ के लिए धन्यवाद ! )

def s(w,h,d):R,M=range,max;S,V,L=' |/';O=w-2;D=d-M(0,d-h);Q=h-M(0,h-d);print('\n'.join([S*(d-i)+L+' -'[i<1]*O+L+S*[h-1,i][i<=D-1]+'/|'[i<=D-1]for i in R(D+M(0,d-h))]+[V+[' -'[i==h],'_'][i<2]*O+V+S*[i-1,d][i>Q]+'/|'[i>Q]for i in R(Q+M(0,h-d),0,-1)]))

के क्रम में 3 पूर्णांक के रूप में इनपुट लेता है width, height, depth। जहाँ भी मैं कर सकता हूँ समय के साथ अधिक गोल्फ जाएगा।

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

स्पष्टीकरण:

इस स्पष्टीकरण के प्रयोजनों के लिए, मान लें कि फ़ंक्शन को तर्कों के साथ निष्पादित किया गया था (3,2,3) जहां 3 की चौड़ाई ( w), 2 की ऊंचाई ( h) है, और 3 की गहराई ( d) है। कहा जा रहा है, मुझे पूरे समारोह का मुख्य भाग दिखाते हुए शुरू करें:

'\n'.join([S*(d-i)+L+' -'[i<1]*O+L+S*[h-1,i][i<=D-1]+'/|'[i<=D-1]for i in R(D+M(0,d-h))]+[V+[' -'[i==h],'_'][i<2]*O+V+S*[i-1,d][i>Q]+'/|'[i>Q]for i in R(Q+M(0,h-d),0,-1)])

यहां, दो सूचियां जो पूरे "घर" को बनाती हैं और फिर शाब्दिक नई लाइनों ( \n) द्वारा एक साथ जुड़ जाती हैं । चलो उन्हें क्रमशः सूची aऔर सूची कहते bहैं, और उनमें से प्रत्येक का विश्लेषण करते हैं:

• यहां सूची aबनाई गई है:

  [S*(d-i)+L+' -'[i<1]*O+L+S*[h-1,i][i<=D-1]+'/|'[i<=D-1]for i in R(D+M(0,d-h))]
  

  इस सूची में dघर की पहली लाइनें शामिल हैं । यहां, iउस श्रेणी में प्रत्येक संख्या 0=>(d-(d-h))+d-hजहां d-h=0नकारात्मक या शून्य हो। शुरू करने के लिए, d-iरिक्त स्थान सूची में जोड़े जाते हैं, उसके बाद ए/ और फिर एक संपीड़ित सशर्त विवरण द्वारा वापस किया जाता है। इस सशर्त विवरण में, w-2यदि रिक्त स्थान की संख्या दी गई है i>1। अन्यथा उसी संख्या -को वापस कर दिया जाता है। फिर, इनका अनुसरण दूसरे द्वारा किया जाता है /, और फिर रिक्त स्थान, जहां रिक्त स्थान की संख्या अब इस बात पर निर्भर करती है कि नहीं i<=d-(d-h)-1। यदि यह है, तो iरिक्त स्थान जोड़े जाते हैं। अन्यथा,h-1 रिक्त स्थान जोड़े जाते हैं। अंत में, यह सब एक /या एक से सबसे ऊपर है |, जहां |अगर i<=d-(d-h)-1, अन्यथा जोड़ा जाता है/जोड़ दिया गया है। 3x2x3प्रिज्म के इस मामले में , यह सूची द्वारा लौटा दी जाएगी a:

        /-/|
       / / |
      / / /
  

• यहां सूची bबनाई गई है:

  [V+[' -'[i==h],'_'][i<2]*O+V+S*[i-1,d][i>Q]+'/|'[i>Q]for i in R(Q+M(0,h-d),0,-1)]`
  

  इस सूची में प्रिज्म की बाकी लाइनें हैं। इस सूची में, iप्रत्येक श्रेणी में पूर्णांक है (h-(h-d))+h-d=>0जहां h-d=0यदि नकारात्मक या शून्य है। इस सूची को बंद करने के लिए, सबसे पहले एक |जोड़ा जाता है क्योंकि ये लाइनें हमेशा एक के साथ शुरू होती हैं |। फिर, या तो एक स्थान, -या _जोड़ा जाता है या नहीं i=hया नहीं, इसके आधार पर i<2। यदि i<2, तो एक _जोड़ा जाता है। अन्यथा, एक -जोड़ा जाता है अगर i=h, या एक स्थान जोड़ा जाता है अगरi>h या i<hया i>2। इस निर्णय के बाद, फिर w-2चुने गए चरित्र की संख्या जोड़ दी जाती है। इसके बाद, एक |और जोड़ा जाता है, और फिर या तोi-1 या dस्थानों की संख्या जोड़ रहे हैं। यदिi>h-(h-d) , तो एdरिक्त स्थान की संख्या को जोड़ा जाता है। अन्यथा,i-1रिक्त स्थान की संख्या को जोड़ा जाता है। अंत में, यह |या तो एक या एक के साथ सबसे ऊपर है/, जिसमें एक |जोड़ा जाता है अगर i>h-(h-d), या /अगर जोड़ा गया है i<=h-(h-d)। 3x2x3प्रिज्म के मामले में , सूची bरिटर्न:

      |-| /
      |_|/
  

2 सूचियाँ बनाए जाने के बाद, वे अंततः शाब्दिक नई लाइनों ( \n) का उपयोग करके जुड़ गए हैं '\n'.join()। यह आपका पूरा किया हुआ प्रिज्म है, और इस मामले में, इस तरह दिखाई देगा:

       /-/|
      / / |
     / / /
    |-| /
    |_|/

Comments

अजगर बूलियन पूर्णांक का मूल्यांकन करते हैं, जिसका अर्थ है कि आपकी अधिकांश टर्नरी जैसी चीजों को संकुचित किया जा सकता है '-_'[f<2]। अंत में, R=range;S,V,L=' |/'अपने शुरुआती चर को निर्दिष्ट करने के लिए काम करता है क्योंकि तार उस स्थिति में ख़ुशी से खुद को आपके लिए खोल देगा।

— वैल्यू इंक

कोई बात नहीं, मैं भूल गया कि पायथन में ऑपरेटर मौजूद नहीं है ... लेकिन बाकी को काम करना चाहिए!

— मान स्याही

@ केविनलाउ-केनी वाह, सुझावों के लिए धन्यवाद! :) मुझे नहीं पता था कि इस तरह से तीखे भाव व्यक्त किए जा सकते हैं!

— आर। काप

जब तक आप इसके अंदर चरों को संशोधित नहीं कर रहे हैं, तब तक आप टर्नरीज़ के लिए उस ट्रिक का उपयोग कर सकते हैं। उदाहरण के लिए, a=1 if b<9 else c=5के रूप में व्यक्त नहीं किया जा सकता [a=1,c=5][b<9]है क्योंकि आप को संशोधित करने के लिए दोनों पहुंच जाएंगे aऔर c। यहाँ PPCG पायथन गोल्फ टिप्स पेज है: codegolf.stackexchange.com/questions/54/…

— मान इंक

आप अभी भी एक त्रिगुट अभी भी वहाँ है कि है '_'if f<2else' -'[f==h]। याद रखें कि बूलियन्स पूर्णांक के रूप में मूल्यांकन करते हैं, इसलिए आप इसे प्राप्त करने के लिए तय किए गए दूसरे को "टर्नरी" कर सकते हैं [' -'[f==h],'_'][f<2]। इसके अलावा, आपने S,V,L=' |/'अभी तक मेरे टिप का उपयोग नहीं किया है।

— वैल्यू इंक