कुंजियों के लिए जंगल नहीं देख सकता

Question

एक प्रोग्राम या फ़ंक्शन लिखें जो किसी भी उचित सुविधाजनक प्रारूप में पूर्णांक की गैर-रिक्त सूची में लेता है जैसे कि 4, 0, -1, -6, 2या [4 0 -1 -6 2]।

एक स्ट्रिंग को प्रिंट या वापस करें जो सूची को एक ASCII कला जंगल के रूप में दर्शाती है जहां प्रत्येक संख्या आनुपातिक ऊंचाई का एक पेड़ बन जाता है। प्रत्येक पेड़ आउटपुट में टेक्स्ट के चार कॉलम लेता है:

• एक सकारात्मक पूर्णांक N एक वृक्ष बन जाता है जिसका आधार __|_और शीर्ष होता है ^ , / \बीच में N परतों के साथ ।

  उदाहरण के लिए, जब N = 1 वृक्ष है

    ^
   / \
  __|_
  

  जब एन = 2 पेड़ है

    ^
   / \
   / \
  __|_
  

  जब एन = 3 पेड़ है

    ^
   / \
   / \
   / \
  __|_
  

  और इसी तरह।

• एक नकारात्मक पूर्णांक N, एक धनात्मक वृक्ष की तरह हो जाता है, सिवाय एक ऊर्ध्वाधर पट्टी के, एक स्थान के बजाय शाखा स्लैश के बीच होता है।

  उदाहरण के लिए, जब एन = -1 पेड़ है

    ^
   /|\
  __|_
  

  जब एन = -2 पेड़ है

    ^
   /|\
   /|\
  __|_
  

  जब एन = -3 पेड़ है

    ^
   /|\
   /|\
   /|\
  __|_
  

  और इसी तरह।

• जब पूर्णांक 0 होता है तो तकनीकी रूप से कोई पेड़ नहीं होता है, बस चार अंडरस्कोर का एक खाली स्थान होता है:

  ____
  

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

एक उदाहरण के रूप में, के लिए उत्पादन 4 0 -1 -6 2होगा

              ^
             /|\
  ^          /|\
 / \         /|\
 / \         /|\  ^
 / \      ^  /|\ / \
 / \     /|\ /|\ / \
__|_______|___|___|__

ध्यान दें कि पेड़ के पैटर्न में हमेशा खाली जगह का एक प्रमुख स्तंभ होता है लेकिन पिछले पेड़ के दाहिने हिस्से को पैड करने के लिए एक अंडरस्कोर जोड़ना पड़ता था।

इसके अलावा:

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

बाइट्स में सबसे छोटा कोड जीतता है।

और ज्यादा उदाहरण

3:

  ^
 / \
 / \
 / \
__|__

-2:

  ^
 /|\
 /|\
__|__

0:

_____

0, 0:

_________

0, 1, 0:

      ^
     / \
______|______

0, -1, 2, -3, 4:

                  ^
              ^  / \
          ^  /|\ / \
      ^  / \ /|\ / \
     /|\ / \ /|\ / \
______|___|___|___|__

Answer 1

पायथ, 48 बाइट्स

j_.t+sm.i,J\_?d++\|sm?>d0\ \|d\^Jms+Jmkd"/\\"QJd

इसे ऑनलाइन आज़माएँ: प्रदर्शन या टेस्ट सूट

पूर्ण स्पष्टीकरण के लिए बहुत आलसी। यहाँ सिर्फ संक्षिप्त अवलोकन है:

मैं पहले कॉलम जनरेट करता हूं। तो छवि:

      ^ 
  ^  /|\
 / \ /|\
__|___|__

के रूप में उत्पन्न हो जाता है:

["_", "_/", "| ^", "_\", "_", "_//", "|||^", "_\\", "_"]

ध्यान दें, कि मैं केवल निचला भाग (रिक्त स्थान के बिना सब कुछ) उत्पन्न कर रहा हूं। और मैं उन्हें नीचे से ऊपर तक उत्पन्न कर रहा हूं। यह बहुत सीधा किया जाता है।

फिर मैं .tस्ट्रिंग्स के लिए रिक्त स्थान को जोड़ने के लिए विधि का उपयोग कर सकता हूं , ताकि प्रत्येक स्ट्रिंग की एक समान लंबाई हो। और बाद में मैं ऑर्डर को रिवर्स करता हूं और प्रिंट करता हूं।

Comments

एक नोट के रूप में: यदि यह एक वास्तविक आउटपुट है, तो आप _आखिरी पेड़ के बाद एक अनुगामी (अंडरस्कोर) जोड़ना भूल गए होंगे ।

— insertusernamehere

@insertusernamehere धन्यवाद, पूरी तरह से अनुगामी की अनदेखी की _।

— 23

Answer 2

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

a=input()
l=max(map(abs,a))
while l+2:s=' _'[l<0];print(s+s.join((([' ^ ','//| \\\\'[x>0::2],'   '][cmp(abs(x),l)],'_|_')[l<0],s*3)[x==0]for x in a)+s).rstrip();l-=1

यह एक पूर्ण कार्यक्रम है जो एक सूची को इनपुट के रूप में स्वीकार करता है। मैं अब भी इस भयावह गड़बड़ को गोल कर रहा हूं।

Answer 3

PHP, 231 277 बाइट्स

इस चुनौती का एक सुंदर आउटपुट है।

$x=fgetcsv(STDIN);for(;$i<2+max(array_map(abs,$x));$i++)for($j=0;$j<count($x);){$_=$x[$j++];$o[$i].=!$i?$_?'__|_':____:(abs($_)>=$i?0>$_?' /|\\':' / \\':($i-1&&abs($_)==$i-1?'  ^ ':'    '));}echo implode("
",array_reverse($o))."_";

एक अल्पविराम से अलग की गई सूची पढ़ता है (व्हाट्सएप वैकल्पिक हैं) STDIN:

$ php trees.php
> 1, 2, 0, -4, 6

Ungolfed

$x=fgetcsv(STDIN);
for(;$i<2+max(array_map(abs,$x));$i++)
    for($j=0;$j<count($x);){
        $_=$x[$j++];
        $o[$i] .= !$i ? $_?'__|_':____
                      : (abs($_)>=$i ? 0>$_?' /|\\':' / \\'
                                     : ($i-1&&abs($_)==$i-1 ? '  ^ ' : '    '));
    }
echo implode("\n",array_reverse($o))."_";

संपादित करता

• सहेजे गए 46 बाइट्स । सरणी आरंभीकरण को छोड़ दिया if/elseगया, टर्नरी ऑपरेटरों के साथ बदल दिया गया और कुछ बाइट्स को बचाने के लिए कुछ चर बनाए गए।

Answer 4

रूबी, 157 156 153 अक्षर

->h{r=[]
h.map{|i|j=i.abs
r+=[s=?_,?/*j+s,i==0?s:?^+(i>0?' ':?|)*j+?|,?\\*j+s].map{|l|l.rjust(h.map(&:abs).max+2).chars}}
r.transpose.map{|l|l*''}*$/+?_}

सिर्फ इसलिए लिखा क्योंकि शुरू में Array.transposeएक अच्छा विचार था। अब और नहीं।

नमूना रन:

2.1.5 :001 > puts ->h{r=[];h.map{|i|j=i.abs;r+=[s=?_,?/*j+s,i==0?s:?^+(i>0?' ':?|)*j+?|,?\\*j+s].map{|l|l.rjust(h.map(&:abs).max+2).chars}};r.transpose.map{|l|l*''}*$/+?_}[[4, 0, -1, -6, 2]]
              ^     
             /|\    
  ^          /|\    
 / \         /|\    
 / \         /|\  ^ 
 / \      ^  /|\ / \
 / \     /|\ /|\ / \
__|_______|___|___|__

Comments

टुकड़ों को एक अलग सरणी में इकट्ठा करने के बजाय उन्हें पहले नक्शे से वापस करने के लिए कम करने के उपयोग से बचने की अनुमति देनी चाहिए।

— manatwork

Answer 5

सी #, 318 बाइट्स

मैंने ऐरे को ट्रांसपोज़ करने की कोशिश की। मुझे यकीन नहीं है कि अगर यह सबसे अच्छा समाधान था।

string F(int[]a){int i=a.Length,j,w=i*4+1,h=0;string f="",o=f;for(;i-->0;){j=a[i];f+=","+" _,".PadLeft(j=j>0?j+3:-j+3,'\\')+(j>3?"^"+"|_,".PadLeft(j,a[i]<0?'|':' '):"_,")+" _,_".PadLeft(j+1,'/');h=h<j?j:h;}f="_".PadLeft(h=h>3?h:2,'\n')+f;for(i+=h<3?1:0;++i<h;)for(j=w;j-->0;)o+=f.Split(',')[j].PadLeft(h)[i];return o;}

स्पष्टता के लिए इंडेंटेशन और न्यूलाइन्स:

string F(int[]a)
{
    int i=a.Length,
        j,
        w=i*4+1,
        h=0;
    string f="",o=f;
    for(;i-->0;){
        j=a[i];
        f+=","+" _,".PadLeft(j=j>0?j+3:-j+3,'\\')+(j>3?"^"+"|_,".PadLeft(j,a[i]<0?'|':' '):"_,")+" _,_".PadLeft(j+1,'/');
        h=h<j?j:h;
    }
    f="_".PadLeft(h=h>3?h:2,'\n')+f;
    for(i+=h<3?1:0;++i<h;)
        for(j=w;j-->0;)
            o+=f.Split(',')[j].PadLeft(h)[i];
    return o;
}