वास्तुविदों को क्षितिज की कल्पना करने में मदद करें

Question

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

सभी इमारतें नदी द्वारा होंगी, इस प्रकार वे सभी संरेखित हैं। आर्किटेक्ट प्रत्येक इमारत की ऊंचाई को इनपुट के रूप में देंगे, और आपके कोड को क्षितिज प्रदर्शित करना चाहिए।

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

आउटपुट के बारे में विवरण और स्पष्टीकरण के लिए, कृपया नीचे दिए गए उदाहरणों पर एक नज़र डालें:

N = 3
 ___
|   |
|   |
|___|

N = 3.5
  _      
 / \
|   |
|   |
|___|

N = 6
 ___
|   |
|   |
|   |
|   |
|   |
|___|

n = 0
_

उदाहरण इनपुट: 3 3.5 0 2

      _
 ___ / \  
|   |   |  ___
|   |   | |   |
|___|___|_|___|

उदाहरण इनपुट: 0 0 2.5 3 0 4 1

             ___
    _  ___  |   |
   / \|   | |   |
  |   |   | |   |___
__|___|___|_|___|___|

लुइसविले ,0 2 1 3.5 0 4 2 4 2 4 6 1 6 0 5 1

                                    ___     ___
                                   |   |   |   |  ___
           _    ___     ___     ___|   |   |   | |   |
          / \  |   |   |   |   |   |   |   |   | |   |
  ___    |   | |   |___|   |___|   |   |   |   | |   |
 |   |___|   | |   |   |   |   |   |   |___|   | |   |___
_|___|___|___|_|___|___|___|___|___|___|___|___|_|___|___|

एएससीआईआई-वर्ण का उपयोग किया जाता है: न्यूलाइन, स्पेस और /\_|(कोड अंक 10, 32, 47, 92, 95, 124)।

नियम:

• यह एक प्रोग्राम बनाने के लिए वैकल्पिक है जो केवल पूर्णांकों को इनपुट के रूप में लेता है, सभी संख्याओं को दो से गुणा करके। इसलिए, लेने के बजाय 3 3.5 2, आपका कार्यक्रम हो सकता है 6 7 4। यदि दूसरा इनपुट प्रारूप चुना जाता है, तो 6 के इनपुट का परिणाम 3 स्टोरी बिल्डिंग में होना चाहिए, 7 में एक 3 स्टोरी बिल्डिंग होनी चाहिए जिसमें पिचिंग छत आदि हों।
• आउटपुट बिल्कुल ऊपर वर्णित के रूप में होना चाहिए, लेकिन रिक्त स्थान और newlines ठीक हैं।
• इनपुट का सटीक प्रारूप वैकल्पिक है। आपकी भाषा में जो कुछ भी श्रेष्ठ है।
• परिणाम को स्क्रीन पर प्रदर्शित किया जाना चाहिए, ताकि आर्किटेक्ट इसे देख सकें।
• आप मान सकते हैं कि कम से कम एक पूर्णांक दिया जाएगा, और केवल मान्य इनपुट दिया जाएगा।

यह कोडगोल्फ है, इसलिए बाइट्स में सबसे छोटा कोड जीत जाता है।

Comments

0.5 की ऊँचाई वाली इमारत कैसी दिखेगी?

— टॉम कारपेंटर 20

वास्तव में इसके बारे में नहीं सोचा था। सबसे स्पष्ट पसंद सिर्फ एक पक्की छत होगी, लगभग किसी हॉबी होम की तरह :-) लेकिन आप चुनने के लिए स्वतंत्र हैं, या आप यह मान सकते हैं कि इनपुट कभी 0.5 नहीं होगा ...

— स्टिव ग्रिफ़िन

फिलहाल अजीब चीजें होती हैं क्योंकि कोई दीवारें नहीं हैं (मुझे लगता है कि 0.5 उच्च मौजूद नहीं था), इसलिए मुझे अपने जवाब पर थोड़ा काम करना होगा।

— टॉम कारपेंटर

मैंने सिर्फ आपके कोड को ऊँचाई 0.5 के साथ आज़माया है, और मैं मानता हूँ, "अजीब" एक बहुत ही वर्णनात्मक शब्द है = PI इसके बारे में विस्तार से नहीं जाना है, इसलिए मुझे यकीन नहीं है कि क्या चल रहा है ... Anyhow, आप जवाब देते हैं पूरी तरह से मान्य, आप मान सकते हैं कि कोई भी 0.5 इमारतें नहीं हैं ...

— स्टीवी ग्रिफिन

Answer 1

पायथन 2, 199 193 188 185 बाइट्स

a=map(int,raw_input().split())
l=max(a)+1|1
while~l:print''.join((x%2*'/  _\\ '[x<l::2]*(x<=l<x+4)or'_ '[x|1!=l>1]*3)[x<1:x+2]+'| '[x<=l>=y]*(x+y>0)for x,y in zip([0]+a,a+[0]))[1:];l-=2

यह एक पूर्ण प्रोग्राम है जो पूर्णांक को इनपुट के रूप में स्वीकार करता है। उदाहरण इनपुट ।

Comments

आश्चर्यजनक! मुझे भविष्य के

— गोल्फों के

Answer 2

MATLAB, 219 209 203 बाइट्स

i=input('');x=1;c=0;m(1:4*numel(i))='_';for a=i;b=fix(a);m(1:b,x)='|';s=95;if a~=b;m(b+2,x+2)=95;s='/ \';end;m(b+1,x+(1:3))=s;x=x+(a>0)*3+1;m(1:b,x)='|';x=x+(a<1&c>0);c=a;end;disp(flipud(m(:,1:x-(a<1))))

यह दुर्भाग्य से ओक्टेव पर काम नहीं करता है । पूरी तरह से निश्चित नहीं है कि, ऐसा लगता है कि इस विवाद / पलटन बिट के साथ कुछ करना है।

इसके अलावा, वर्तमान में 0.5 ऊंचाई की इमारत जैसी कोई भी परिभाषा नहीं है, न ही उनका कोई उल्लेख है, इसलिए इस कोड में मुझे लगता है कि वे अस्वीकृत हैं।

निम्नलिखित कुछ और अधिक पठनीय तरीके से कोड है:

i=input(''); %e.g. [0 0 2 1 3.5 0 4 2 4 2 4 6 1 6 0 5 1 0 0 1 0]
x=1;
c=0;
m(1:4*numel(i))='_';
for a=i;
    b=fix(a);
    m(1:b,x)='|';
    s=95;
    if a~=b;
        m(b+2,x+2)=95;
        s='/ \';
    end;
    m(b+1,x+(1:3))=s;
    x=x+(a>0)*3+1;
    m(1:b,x)='|';
    x=x+(a<1&c>0);
    c=a;
end;
disp(flipud(m(:,1:x-(a<1))))

---

पहले हम एक ऐरे के रूप में एक इनपुट लेते हैं, और कुछ वैरिएबल इनिशियलाइज़ेशन करते हैं।

i=input(''); %e.g. [0 0 2 1 3.5 0 4 2 4 2 4 6 1 6 0 5 1]
x=1;
c=0;

क्योंकि शून्य ऊंचाई वाली इमारतों में दर्द होता है - वे मूल रूप से एक चौड़ाई के साथ समाप्त होते हैं जो इस बात पर निर्भर है कि वे आगे क्या हैं (हालांकि जो छपा है वह बदलता नहीं है), हम सभी इमारतों के लिए पर्याप्त जमीन खींचकर चीजों को सरल बनाते हैं। हम मानते हैं कि प्रत्येक इमारत 4 वर्णों वाली चौड़ी होगी (क्योंकि आसन्न इमारतें एक साथ विलीन हो जाती हैं) - शून्य ऊँचाई वाले नहीं हैं, लेकिन बाद में अतिरिक्त छंटनी की जाएगी।

m(1:4*numel(i))='_';

अब हम प्रत्येक भवन को बारी-बारी से बनाते हैं।

for a=i

पहले हमें ऊंचाई का पूर्ण भाग मिलता है क्योंकि यह निर्धारित करेगा कि कितने '?' ज़रुरत है।

    b=fix(a);

अब इस इमारत के लिए दीवार में ड्रा करें - यदि दो आसन्न इमारतें हैं, तो इस नए के लिए दीवार पिछले कॉलम से दीवार के समान ही होगी।

    m(1:b,x)='|';

यह देखने के लिए जांचें कि क्या यह आधी ऊंचाई की इमारत है। यदि यह है, तो छत अलग होगी। आधी ऊँचाइयों के लिए, छत पूरी होने जा रही है, / \जबकि पूरी ऊँचाई वाले होंगे ___(मतलाब एक एकल अंडरस्कोर से इसे दोहराएगा, इसलिए वहां कुछ बाइट्स बचाएं)। आधी ऊंचाई की इमारतों के लिए एक पंक्ति में एक अतिरिक्त छत है, इसलिए इसे भी जोड़ा जाता है।

    s=95;
    if a~=b;
        m(b+2,x+2)=95;
        s='/ \';
    end;

छत में खींचना

    m(b+1,x+(1:3))=s;

अब अगली इमारत की शुरुआत में जाएं और साझा दीवार में ड्रा करें (यदि इस बिंदु पर दीवार बहुत कम है, तो इसे अगले भवन के खींचने पर बड़ा बनाया जाएगा)। ध्यान दें कि शून्य ऊँचाई वाली इमारतें 1 चौड़ी हैं, सामान्य इमारतें 4 चौड़ी हैं, इसलिए हम सरल करते हैं कि एक और नहीं तो क्या होगा- (a 0) दशमलव संख्या के रूप में एक बूलियन नहीं।

    x=x+(a>0)*3+1;
    m(1:b,x)='|';

इसके बाद शून्य ऊंचाई वाली इमारतों के साथ काम करने के लिए हैकिंग का एक सा हिस्सा आता है। मूल रूप से यह क्या कहता है यदि यह भवन शून्य ऊंचाई का था, और इससे पहले वाला नहीं था, इसका मतलब है कि अगले भवन के स्थान पर 1 की वृद्धि की आवश्यकता है क्योंकि दो अन्य इमारतों के बीच में एक शून्य ऊंचाई वाली इमारत प्रभावी रूप से दो बार चौड़ी है - यह अतिरिक्त दीवार के लिए खाते जो आम तौर पर आसन्न इमारत के साथ साझा किए जाते हैं। हम अगली बार इस जाँच को करने के लिए इस भवन की ऊँचाई का भी ध्यान रखते हैं।

    x=x+(a<1&c>0);
    c=a;
end;

एक बार हो जाने के बाद, बिल्डिंग मैट्रिक्स को सही तरीके से ऊपर फ्लिप करें, और इसे प्रदर्शित करें। ध्यान दें कि हम यहां किसी अतिरिक्त जमीन को भी ट्रिम कर देते हैं।

disp(flipud(m(:,1:x-(a<1))))

---

इसलिए, जब हम इस स्क्रिप्ट को चलाते हैं, तो हमें हमारे इनपुट के लिए कहा जाता है, उदाहरण के लिए:

[0 0 2 1 3.5 0 4 2 4 2 4 6 1 6 0 5 1 0 0 1 0]

यह तब भवन उत्पन्न करता है और परिणाम प्रदर्शित करता है। उपरोक्त इनपुट के लिए, निम्नलिखित उत्पन्न होता है:

                                     ___     ___                   
                                    |   |   |   |  ___             
            _    ___     ___     ___|   |   |   | |   |            
           / \  |   |   |   |   |   |   |   |   | |   |            
   ___    |   | |   |___|   |___|   |   |   |   | |   |            
  |   |___|   | |   |   |   |   |   |   |___|   | |   |___    ___  
__|___|___|___|_|___|___|___|___|___|___|___|___|_|___|___|__|___|_

Comments

बहुत अच्छा किया!

— स्टिव ग्रिफ़िन

Answer 3

कोटलिन, 447 442 बाइट्स

val a={s:String->val f=s.split(" ").map{it.toFloat()}.toFloatArray();val m=(f.max()!!+1).toInt();for(d in m downTo 0){var l=0f;for(c in f){val h=c.toInt();print(if(h==d&&d!=0)if(h<l-0.5)"|" else{" "}+if(c>h)"/ \\" else "___" else if(h<d)if(d<l-0.5)"|" else{" "}+if(h==0)" " else if((c+0.5).toInt()==d)" _ " else "   " else{if(h==0)if(l<1)"  " else "| " else "|   "}.replace(' ',if(d==0)'_' else ' '));l=c;};if(d<l-0.5)print("|");println();}}

Ungolfed संस्करण:

val ungolfed: (String) -> Unit = {
    s ->

    val floats = s.split(" ").map { it.toFloat() }.toFloatArray()
    val maxH = (floats.max()!! + 1).toInt()

    for (drawHeight in maxH downTo 0) {
        var lastBuildingH = 0f
        for (f in floats) {
            val buildingH = f.toInt()
            if (drawHeight == 0) {
                // Baseline
                if (buildingH == 0)
                    if (lastBuildingH.toInt() == 0) print("__")
                    else print("|_")
                else print("|___")
            } else if (buildingH == drawHeight) {
                // Ceiling
                if (buildingH < lastBuildingH - 0.5) print("|")
                else print(" ")
                if (f > buildingH) print("/ \\")
                else print("___")
            } else if (buildingH < drawHeight) {
                // Above building
                if (drawHeight < lastBuildingH - 0.5) print("|")
                else print(" ")
                if (buildingH == 0) print(" ")
                else {
                    if ((f + 0.5).toInt() == drawHeight) print(" _ ")
                    else print("   ")
                }
            } else {
                if (buildingH == 0) print("| ")
                else print("|   ")
            }
            lastBuildingH = f;
        }
        if (drawHeight < lastBuildingH - 0.5) print("|")
        println()
    }
}

Answer 4

पायथन 2, 357 306 299 294 287 281 276 बाइट्स

def s(l):
 d=len(l)+1;l=[0]+l+[0];h=(max(l)+3)/2;o=''
 for i in range(d*h):
  a=l[i%d+1];c=l[i%d];b=2*(h-1-i/d);o+="|"if(a>b+1)+(c>b+1)else" "*(a+c>0);o+=" _/__  _\\"[a-b+1::3]if b*(1>=abs(a-b))else" "*(1+2*(a>0))
  if b==0:o=o.replace(" ","_")
  if i%d==d-1:print o[:-1];o=''

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

संपादित करें: xsot बेहतर है

स्पष्टीकरण:

d=len(l)+1;l=[0]+l+[0];m=max(l);h=m/2+m%2+1;o=''

dसरणी की लंबाई से 1 अधिक है, क्योंकि हम सूची के प्रत्येक छोर पर दूसरे तत्व से शून्य को जोड़ने जा रहे हैं जो हमने शून्य से अंत में जोड़ा है। hड्राइंग की ऊंचाई है। (हमें इस गणना में 2 से भाग करना होगा क्योंकि हम दोगुने प्रतिनिधित्व का उपयोग कर रहे हैं, जिसका उपयोग हम विशेष रूप से सभी जगह पर किलों को तैरने से बचने के लिए करते हैं। हम इतनी विषम ऊंचाइयों - नुकीली इमारतों को विभाजित करने से पहले 1 जोड़ते हैं। नियमित प्रकार की तुलना में थोड़ा अधिक निकासी प्राप्त करें।) oआउटपुट स्ट्रिंग है।

 for i in range(d*h):

पाश के लिए एक एकल में लूप के लिए एक डबल टकराने के लिए एक मानक चाल। एक बार हम करते हैं:

  a=l[i%d+1];c=l[i%d];b=2*(h-1-i/d)

हमने अब जैसा पूरा किया है:

for b in range(2*h-2,-2,-2):
 for j in range(d):
  a=l[j+1];c=l[j]

लेकिन एक तरह से जो हमें दस बाइट्स से बचाते हैं (निम्नलिखित पंक्तियों पर व्हॉट्सएप सहित)।

  o+="|"if(a>b+1)+(c>b+1)else" "*(a+c>0)

किसी भी दीवार को किसी भी समय या वर्तमान इमारत या पिछले भवन की ऊँचाई, वर्तमान रेखा से ऊँची है, जब तक यहाँ कम से कम एक इमारत की सीमा नहीं है। यह निम्नलिखित सशर्त के बराबर है:

  o+=("|" if a>b+1 or c>b+1 else " ") if a or c else ""

जहाँ b वर्तमान स्कैन ऊंचाई है, a वर्तमान भवन की ऊँचाई है, और c पिछली इमारत की ऊँचाई है। सशर्त का उत्तरार्द्ध जमीन की जगहों के बीच दीवारों को लगाने से रोकता है।

  o+=" _/__  _\\"[a-b+1::3]if b*(1>=abs(a-b))else" "*(1+2*(a>0))

यह वह हिस्सा है जो सही छत को खींचता है, भवन की ऊंचाई को वर्तमान स्कैन ऊंचाई के साथ तुलना करके छत के हिस्सों का चयन करता है। यदि एक छत यहां नहीं जाती है, तो यह उचित स्थान (3 जब यह एक वास्तविक इमारत है, उदाहरण के लिए, एक> 0, अन्यथा 1) प्रिंट करता है। ध्यान दें कि जब हम जमीनी स्तर पर होते हैं, तो यह कभी भी छत खींचने का प्रयास नहीं करता है, जिसका अर्थ है कि 0.5 आकार की इमारतों को नुकीले छत नहीं मिलते हैं। ओह अच्छा।

  if b==0:o=o.replace(" ","_")

जब हम जमीनी स्तर पर होते हैं, तो हम रिक्त स्थान के बजाय अंडरस्कोर चाहते हैं। हम बस उन सब को यहां एक बार में बदल देते हैं।

  if i%d==d-1:print o[:-1];o=''

अगली पंक्ति को संसाधित करने से ठीक पहले, वर्तमान को प्रिंट करें और आउटपुट लाइन को साफ़ करें। हम अंतिम चरित्र को काट देते हैं क्योंकि यह "_" है जो कि हमने जमीन की जगह के अनुरूप है जिसे हमने फ़ंक्शन की शुरुआत में एक शून्य जोड़कर जोड़ा था। (हमने कहा कि शून्य है इसलिए हमें एक सही दीवार को जोड़ने के लिए एक विशेष मामला नहीं जोड़ना होगा, अगर यह मौजूद है, जो कि 0 से जोड़कर हमने "_" को काट दिया है, तो इससे कहीं अधिक कोड जोड़ देगा।

Comments

कार-गोल्फ। वाह। (इसके अलावा, +1)

— ताली बजाएं

Answer 5

अजगर ३

725 बाइट्स

608 बाइट्स

गोल्फ कोड:

import sys,math;
m,l,w,s,bh,ls,ins,r,a="|   |","___","|"," ",0,[],[],range,sys.argv[1:]
def ru(n):return math.ceil(n)
def bl(h,n):
    if(n>ru(h)):return(s*5,s)[h==0]
    if(h==0):return"_"
    if(n==0):return w+l+w
    if(n<h-1):return m
    return("  _  "," / \ ")[n==ru(h)-1]if(h%1)else(s+l+s,m)[n==h-1]
for arg in a:
    f=ru(float(arg))
    if(bh<f):bh=f
for i in r(bh,-1,-1):
    ln=""
    for bld in a:ln+=bl(float(bld),i)
    ls.append(ln)
for i in r(len(ls[-1])-1):
    if(ls[-1][i]==ls[-1][i+1]==w):ins.append(i-len(ins))
for ln in ls:
    for i in ins:ln=(ln[:i]+ln[i+1:],ln[:i+1]+ln[i+2:])[ln[i]==w]
    print(ln)

यहां अनलॉक्ड कोड है। कुछ टिप्पणियां हैं लेकिन मूल विचार दोहरी दीवारों वाले भवनों का निर्माण करना है, इसलिए नीचे की रेखा इस प्रकार है:

_|___||___|_|___||___|

फिर उन दोहरी दीवारों का सूचकांक प्राप्त करने और उन स्तंभों को हटाने के लिए ताकि हम प्राप्त करें:

_|___|___|_|___|___|

कोड:

import sys
import numbers
import math

mid="|   |";
l="___";
w="|";
s=" ";

def printList(lst):
    for it in lst:
        print(it);

# h = height of building
# l = line numeber starting at 0
def buildingline(h,n):
    #if (h==0):
    #   return " " if(n>math.ceil(h)) else "   ";
    if(n>math.ceil(h)):
        return s if(h == 0) else s*5;
    if(h==0): return "_";
    if(n==0): return w+l+w;
    if(n<h-1): return mid;
    if(h.is_integer()):
        return mid if(n==h-1) else  s+l+s;
    else:
        return " / \ " if (n==math.ceil(h)-1) else "  _  "; 
# max height
bh=0;

for arg in sys.argv[1:]:
    f = math.ceil(float(arg));
    if(bh<f):bh=f;

# lines for printing
lines = []

for i in range(bh,-1,-1):
    line="";
    for bld in sys.argv[1:]:
        bld=float(bld);
        line += buildingline(bld,i);
        #lh = bld;
    lines.append(line);

#for line in lines:
#   print(line);
#printList(lines);


# column merging
#find indexes for merging (if there are | | next to each other)
indexes = [];
for i in range(len(lines[-1])-1):
    if (lines[-1][i]=='|' and lines[-1][i+1] == '|'):
        indexes.append(i-len(indexes));

#printList(indexes);

#index counter
for line in lines:
    newLine = line;
    for i in indexes:
        if newLine[i] == '|' :
            newLine=newLine[:i+1] + newLine[i+2:];
        else : newLine = newLine[:i] + newLine[i+1:];
    print(newLine);

कुछ गोल्फ करने का समय!

Comments

आप यहाँ एक नज़र रखना चाहते हो सकता है । मुझे लगता है कि यहां बहुत सारी गोल्फिंग क्षमता है =) मैं केवल मूल पायथन को जानता हूं, इसलिए मैं कुछ भी विशिष्ट नहीं सुझा सकता हूं जो मुझे डर लगता है ...

— स्टिव ग्रिफिन

यह मुझे ऐसा लगता है जैसे आपने रिक्त स्थान हटा दिए हैं और चर नामों को छोटा कर दिया है, लेकिन बाकी को अपरिवर्तित रखा है। उदाहरण के लिए, आपको कुछ छोरों से छुटकारा पाने के लिए चतुर तरीके खोजने की कोशिश करनी चाहिए, कम तुलनाओं आदि का उपयोग करना चाहिए, जैसे ru(n):return math.ceil(n)कि गोल्फ की तरह मायने रखता है, लेकिन फिर भी ... कृपया इसे नकारात्मक तरीके से न लें, मैं नहीं हूं; अच्छा गोल्फर, और यकीन है कि नरक के रूप में एक अच्छा प्रोग्रामर नहीं है। मेरा सुझाव है कि आप इसे कुछ सुधारने की कोशिश करें ... यह वास्तव में एक तरह का मज़ा है जब आपको एहसास होता है कि आप इसे छोटा कर देंगे। मैं कुछ दिनों पहले कई से 120 से 55 के बीच चला गया। तो यह संभव है भले ही आप इसमें नए हों।

— स्टू ग्रिफिन

@StewieGriffin उस लिंक के लिए धन्यवाद! मैं वास्तव में कोड-गोल्फिंग के लिए एक नौसिखिया हूं इसलिए यह मेरे लिए कोड-गोल्फिंग करने के बजाय वास्तविक कार्य को पूरा करने के बारे में अधिक है। लेकिन विभिन्न भाषाओं की संभावनाओं की खोज करना आश्चर्यजनक है

— Cajova_Houba

FTR: कुछ और अधिक जटिल चुनौतियों के लिए, जैसे कि यह एक, मैं इसे अपने आप समाप्त करने के लिए खुश

— होऊंगा

Answer 6

PHP, 307 297 293 बाइट्स

<?$r=str_pad("",$p=((max($argv)+1)>>1)*$w=4*$argc,str_pad("\n",$w," ",0));for(;++$i<$argc&&$r[$p++]=_;$m=$n)if($n=$argv[$i]){$q=$p+=!$m;eval($x='$r[$q-1]=$r[$q]=$r[$q+1]=_;');for($h=$n>>1;$h--;$q-=$w)$r[$q-2]=$r[$q+2]="|";$n&1?($r[$q-1]="/")&($r[$q-$w]=_)&$r[$q+1]="\\":eval($x);$p+=3;}echo$r;

कमांड लाइन से तर्क 2 * लेता है। फ़ाइल को सहेजना, साथ चलाना php <filename> <parameters>।

टूट - फूट

// initialize result    
$r=str_pad("",              // nested str_pad is 3 bytes shorter than a loop
    $p=                     // cursor=(max height-1)*(max width)=(start of last line)
    ((max($argv)+1)>>1)     // max height-1
    *
    $w=4*$argc              // we need at least 4*($argc-1)-1, +1 for newline
    ,
    // one line
    str_pad("\n",$w," ",0)  // (`str_pad("",$w-1)."\n"` is one byte shorter,
);                          // but requires `$w+1`)

// draw skyline
for(;
    ++$i<$argc              // loop through arguments
    &&$r[$p++]=_                // 0. draw empty ground and go one forward
    ;
    $m=$n                       // 7. remember value
)
    if($n=$argv[$i])            // if there is a house
    {
        $q=                         // 2. copy $p to $q
        $p+=!$m;                    // 1. go one forward if there was no house before this
        // offset all further positions by -2 (overwrite empty ground, share walls)
        eval($x=                    // 3. draw floor
        '$r[$q-1]=$r[$q]=$r[$q+1]=_;'
        );
        for($h=$n>>1;$h--;$q-=$w)   // 4. draw walls
            $r[$q-2]=$r[$q+2]="|";
        $n&1                        // 5. draw roof
            ?($r[$q-1]="/")&($r[$q-$w]=_)&$r[$q+1]="\\"
            :eval($x)               // (eval saved 7 bytes)
        ;                           // (ternary saved 6 bytes over `if`)
        $p+=3;                      // 6. go three forward (5-2)
    }

// output
echo$r;

Answer 7

C ++, ungolfed

(या शायद असहनीय)

मान लें कि 100 से कम तत्व हैं और प्रत्येक तत्व 100 से कम है s। इमारतों की संख्या (इनपुट में आवश्यक) है।

#include <iostream>
using namespace std;
int main()
{
float a[100];
int i,j,s;
cin>>s;
for(i=0;i<s;++i)
 cin>>a[i];
for(i=100;i>=1;--i)
{
for(j=0;j<s;++j)
{
if((a[j]>=i)||(a[j-1]>=i))
 cout<<"|";
else
 cout<<" ";
if(i==1)
 cout<<"___";
else if(a[j]+1==i)
 cout<<"___";
else if(a[j]+1.5==i)
 cout<<" _ ";
else if(a[j]+0.5==i)
 cout<<"/ \\";
else cout<<"   ";
}
if(a[s-1]>=i)
 cout<<"|";
cout<<endl;
}
}

Comments

आउटपुट में कुछ त्रुटियां हैं ... ग्राउंड 3 वर्ण चौड़ा है (यह केवल 1 होना चाहिए), और अंतिम दीवार गायब है।

— स्टीवे ग्रिफिन

@StewieGriffin जब मैं इसे पोस्ट कर रहा था तब भी मैं त्रुटियों को सुलझा रहा था। 1. मैंने आखिरी दीवार जोड़ दी है। 2. मैदान को 3 वर्णों का चौड़ा होना चाहिए, क्योंकि तिरछी छत / _ \ _ 3 वर्णों वाली चौड़ी होती है।

— भूत_न_थे_कोड १४

* इमारतों के बीच की जमीन , अंदर नहीं।

— स्टीवी ग्रिफिन

यदि आप अभी भी इस पर काम कर रहे हैं, तो आप प्रतीक्षा करना चाह सकते हैं, लेकिन यदि आप नए अंक और इंडिकेशन को हटाते हैं, तो आप कई बाइट्स से छुटकारा पा सकते हैं । मैं जमीन समस्या तय नहीं किया है, लेकिन यह काम करता है के बजाय 0.346 बाइट्स 401

— Stewie ग्रिफिन

@StewieGriffin मैं वास्तव में एक गोल्फ का जवाब प्रस्तुत करने का इरादा नहीं है क्योंकि यह वैसे भी बहुत लंबा रास्ता है। मैं शर्त लगा सकता हूं कि बेहतर भाषाएं मौजूद हैं जहां यह 100 बाइट्स के तहत किया जाता है। इसलिए मेरा कोड दूसरों के लिए एक संदर्भ समाधान का अधिक है।

— भूत_न_थे_कोड 15