एक सरणी से एक पेड़ खींचना

Question

एकल-अंक पॉजिटिव पूर्णांकों (संभवतः गारंटी नहीं है) के संभवतः नेस्टेड, गैर-खाली सरणी को देखते हुए, बॉक्स-ड्राइंग पात्रों का उपयोग करते हुए, एक पेड़ के रूप में ASCII- कला प्रतिनिधित्व का उत्पादन किया जाता है ┌ ┴ ┐ ─ │ ┬ ┼। (ये कोड पृष्ठ 437 से कॉपी किए गए थे, लेकिन आप किसी भी समकक्ष प्रतिनिधित्व का उपयोग कर सकते हैं)।

सरणी का प्रत्येक पूर्णांक वृक्ष का एक पत्ता होना चाहिए। सरणी में गहरे समान स्तर वाले तत्व पेड़ के समान स्तर पर मौजूद होने चाहिए। सभी तत्वों को अलग-अलग व्हाट्सएप द्वारा अलग-अलग होना चाहिए (यह निर्धारित करने के लिए कि आपके बीच कितना विस्तृत, न्यूनतम एक स्थान है)।

उदाहरण के लिए, दी गई सारणी [[1, [2]], [3, [4, 5]]], निम्नलिखित पेड़ का उत्पादन करती है

 ┌─┴─┐
┌┴┐ ┌┴─┐
1 │ 3 ┌┴┐
  2   4 5

सरणी के [1, 2, 3]लिए पेड़ की तरह लग सकता है

┌─┼─┐
1 2 3

लेकिन सरणी की [[1, 2, 3]]तरह दिखेगा

  │
┌─┼─┐
1 2 3

जबकि सरणी की [1, [1, [1, [1]]]]तरह लग सकता है

 ┌─┴┐
 1 ┌┴─┐
   1 ┌┴┐
     1 │
       1

अधिक जटिल उदाहरण के रूप में, [1, [[[2, 3], 4], 5]]हो सकता है

┌┴───┐
1  ┌─┴┐
 ┌─┴┐ 5
┌┴┐ 4
2 3

या कई अन्य रूपांतर।

---

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

Comments

[1,[[[2,3],4],5]]यह एक दिलचस्प परीक्षण मामला हो सकता है क्योंकि इसे जड़ को कृत्रिम रूप से विस्तारित करने की आवश्यकता होती है इसलिए दायाँ उपप्रकार बाएं सबट्री से नहीं टकराता है।

— प्रहार

@Poke एक उदाहरण के रूप में जोड़ा गया। उस परीक्षण मामले के लिए कई संभावित बदलाव हैं।

— AdmBorkBork

उस परीक्षण मामले के लिए पहला उदाहरण सही नहीं हो सकता। यही कारण है कि पता चलता है कि दूसरा तत्व है करने के लिए अगले 13 आइटम की एक सरणी है: [2,3], 4, और 5। लेकिन 4 और 5 आसन्न नहीं हैं।

— ड्रेको

जो [1, [[[2, 3]], [4], 5]]मेरे जैसा दिखता है ।

— नील

इन वैकल्पिक इनपुट स्वरूपों में से कौन सा (यदि कोई है) स्वीकार्य होगा?

— 22

Answer 1

पायथन 3 , 400 393 390 बाइट्स

L=len
S,*K=' ┴┼│123456789'
def T(x):
 try:return[str(x+0)]
 except:
  z=[*map(T,x)];q=max(map(L,z))
  for p in z:p+=[S*L(p[0])]*(q-L(p))
  b=[S.join(a)for a in zip(*z)];t=b[0];l=L(t);s=0;e=L(z);r=[S]*l
  if e<2:return['│'.center(l),*b]
  for i in range(l):
   if t[i]in K:s+=1;r[i]='┬┌┐'[(s<e)-(s>1)]
   elif 0<s<e:r[i]='─'
  c=l//2;r[c]=K[r[c]=='┬'];return[''.join(r),*b]

ऊपर से नीचे तक तार की एक सूची देता है।

संपादित करें 1: 7 बाइट्स ┴┼(2 बाइट्स की शुद्ध बचत) के दोहराव से बचकर , एक स्ट्रिंग से 0 काटकर, ड्रॉइंग कैरेक्टर कैसे चुने जाते हैं ┬┌┐( <इसके स्थान पर उपयोग करें ==) को बदलकर, और एक L(z)आई की जगह लेने से चूक गए।e

EDIT 2: -2 बाइट्स ओव्स के लिए धन्यवाद और केविन क्रूज़सेन के लिए -1 बाइट धन्यवाद

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

Ungolfed

def layer(item):
    if isinstance(item, int):
        return [str(item)]
    else:
        subs = [layer(sub) for sub in item]
        longest = max(map(len, subs))
        for sub in subs:
            sub += [' ' * len(sub[0])] * (longest - len(sub))
        below = [' '.join(l) for l in zip(*subs)]
        top = below[0]
        l = len(top)
        if len(subs) == 1:
            return ['│'.center(l), *below]
        seen = 0
        expected = len(subs)
        builder = [' '] * l
        for i in range(l):
            c = top[i]
            if c in '┴┼│123456789':
                seen += 1
                if seen == 1:
                    builder[i] = '┌'
                elif seen == expected:
                    builder[i] = '┐'
                else:
                    builder[i] = '┬'
            elif 0 < seen < expected:
                builder[i] = '─'
        center = l // 2
        if builder[center] == '┬':
            builder[center] = '┼'
        else:
            builder[center] = '┴'
        return [''.join(builder), *below]

पत्तियों से एक पेड़ बनाता है, एक समय में एक परत।

Comments

मैंने आपके TIO लिंक में परीक्षण-मामलों को जोड़ दिया है इसे ऑनलाइन आज़माएं!

— pizzapants184

अच्छा जवाब! आप इसे दो बाइट्स द्वारा इस तरह से वैरिएबल में स्पेस असाइन करके छोटा कर सकते हैं S,*K=' ┴┼│123456789':।

— अंडा

e==1e<2एक बाइट को बचाने के लिए हो सकता है (मुझे नहीं लगता कि यह कभी 0 हो सकता है, क्योंकि चुनौती बताती है कि इनपुट गैर-खाली है - और खाली इनपुट पहले से ही max(map(L,z))उस मामले में वैसे भी विफल हो गए हैं ।)

— केविन क्रूज़सेन

Answer 2

स्वच्छ , 544 506 बाइट्स

एसई / टीआईओ पर अमान्य यूटीएफ -8 से बचने के लिए एस्केप का उपयोग किया जाता है, लेकिन एक बाइट के रूप में गिना जाता है क्योंकि वे वैध शाब्दिक हैं

import StdEnv,Data.List;::T=I Int|L[T];$l#m= @l#k=map maxList(transpose m)=flatlines[[last[' ':[(\_|v<0|w<[j]|q>hd w|q<last w|any((==)q)w|q==j='\305'='\302'|q==j='\301'='\304'='\277'='\332'='\263'=toChar v+'0')0\\[v,r,j:w]<-m|r/2==p&&q>=hd w&&q<=last w]]\\q<-[0..k!!3]]\\p<-[0..k!!1]];@(L l)#p=twice(\p=[[v,r+1:[e+sum([2\\[v:_]<-i|0<=v]++zipWith(\c j=j!!2-c!!3)t(takeWhile(\[z:_]=v+z< -1)(tl t)))-x!!1\\e<-x]]\\i<-inits p&t<-tails p&[v,r:x]<-p])(concatMap@l)#g=[g\\[_,2,g:_]<-p]=[[-1,0,(hd g+last g)/2:g]:p];@(I i)=[[i,0,0,0]];

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

प्रारूप में इनपुट लेता है L[I 3, L[I 4, I 5], I 2]..

पेड़ों को नीचे से ऊपर, दाएं से बाएं जोड़ता है, फिर दाएं से बाएं तक की दूरी को समायोजित करता है।

छंटनी, छांटना:

import StdEnv, Data.List;
:: T = I Int | L [T];
$ l
    #m = @l
    #k = map maxList (transpose m)
    = flatlines [
        [
            last[
                ' ':
                [
                    if(v < 0)
                        if(w < [j])
                            if(q > hd w)
                                if(q < last w)
                                    if(any ((==) q) w)
                                        (
                                            if(q == j)
                                                '\305'
                                                '\302'
                                        )(
                                            if(q == j)
                                                '\301'
                                                '\304'
                                        )
                                    '\277'
                                '\332'
                            '\263'
                        (toChar v + '0')
                    \\ [v, r, j: w] <- m
                    | r/2 == p && q >= hd w && q <= last w
                ]
            ]
            \\ q <- [0..k!!3]
        ]
        \\p<-[0..k!!1]
    ];
@ (L l)
    #p = twice
        ( \p
            = [
                [
                    v, r + 1:
                    map
                        (
                            (+)
                            (
                                sum [2 \\ [v: _] <- i| 0 <= v]
                                + sum (
                                    zipWith
                                        (
                                            \[_, _, _, c: _] [_, _, j: _] = j - c
                                        )
                                        t
                                        (
                                            takeWhile (\[v: _] = v < 0) (tl t)
                                        )
                                ) * (1 - sign (v + 1))
                                - x!!1
                            )
                        )
                        x
                ]
            \\ i <- inits p
            &  t <- tails p
            &  [v, r: x] <- p
            ]
        )
        (concatMap @ l)
    #g = [g \\ [_, 2, g: _] <- p]
    =[[-1, 0, (hd g + last g)/2: g]: p];
@ (I i) = [[i, 0, 0, 0]];

Answer 3

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

↶≔⟦⟦θ⟧⟧ηＦη«≔⊟ιζ¿⁼Ｉζ⪫⟦ζ⟧ω⊞υ⊞ＯιζＦＬζ⊞η⁺ι⟦⊖Ｌζκ§ζκ⟧»Ｗυ«≔⌊υι≔Φυ¬⁼κιυＪ±⊗Ｌυ⊘⊖ＬιＩ⊟ιＷι«≔⊟ιζ¿ζ«←§┐┬‹ζ⊟ιＷ⁼ＫＫψ←─≔⁰ι»¿⊟ι┌¶┴¦│

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

↶

डिफ़ॉल्ट ड्राइंग दिशा को ऊपर तक बदलें क्योंकि हम कुछ भी सही करने के लिए आकर्षित नहीं करते हैं।

≔⟦⟦θ⟧⟧η

पहला कदम एक सूचकांक प्रतिनिधित्व जो इनपुट के लिए subarrays, जैसे के सूचकांकों के साथ एक साथ सभी प्रविष्टियों की एक सूची है में नेस्टेड सरणी प्रतिनिधित्व कन्वर्ट करने के लिए है है और इसलिए सूची हम चाहते है । हम प्रक्रिया के लिए एक एकल प्रविष्टि से शुरू करते हैं जो एक सूची है जो वर्तमान सूचकांकों (यानी अब तक कोई नहीं) और मूल इनपुट की एक सूची है।q=[1, [[[2, 3]], [4], 5]]5q[1][2]1, 2

Ｆη«

जैसा कि हम उन्हें संसाधित करते हैं, सरणियों पर लूप करें। (यदि आप इसे पुनरावृति के दौरान धकेलते हैं, तो चारकोल एक सूची पर चलना जारी रखेगा।)

≔⊟ιζ

प्रक्रिया करने के लिए अगला सरणी प्राप्त करें।

¿⁼Ｉζ⪫⟦ζ⟧ω

क्या यह वास्तव में एक सरणी के बजाय एक अदिश राशि है?

⊞υ⊞Ｏιζ

यदि ऐसा है, तो हमारे पास जो सूची थी वह वास्तव में सूचकांकों की सूचियों की अंतिम सूची में है।

ＦＬζ

अन्यथा, इस सरणी में प्रत्येक तत्व पर लूप करें ...

⊞η⁺ι⟦⊖Ｌζκ§ζκ⟧»

... और इसे आगे की प्रक्रिया के लिए अपनी नई सूचकांक सूची के साथ सहेजें। सरणी का अधिकतम सूचकांक भी सहेजा जाता है जिसका उपयोग सरणी के अंतिम तत्व को विशेष-केस के लिए किया जाता है।

Ｗυ«

अब हम इंडेक्स लिस्ट की सूची पर लूप करने के लिए तैयार हैं। हालाँकि, सूची लेक्सोग्राफिक क्रम में नहीं है, इसलिए हम इसे सीधे प्रसारित नहीं कर सकते।

≔⌊υι

अगला तत्व lexicographic क्रम में खोजें।

≔Φυ¬⁼κιυ

इसे सूची से हटा दें।

Ｊ±⊗Ｌυ⊘⊖Ｌι

आउटपुट में स्केलर की स्थिति पर जाएं। हम इस गणना की गणना कर सकते हैं कि हम अपने द्वारा आउटपुट किए जाने वाले स्केलरों की संख्या की गणना कर सकते हैं और हम इसकी सूची में प्रविष्टियों की संख्या भी जानते हैं।

Ｉ⊟ι

दरअसल स्केलर को प्रिंट करें।

Ｗι«

सूचकांक सूची में प्रविष्टियों पर लूप। फिर से, यह सरल पुनरावृत्ति नहीं है, क्योंकि प्रविष्टियाँ जोड़े में आती हैं, और हमें लूप से बाहर निकलने में भी सक्षम होना चाहिए।

≔⊟ιζ

सूची से अगला सूचकांक निकालें।

¿ζ«

यदि यह सूची में पहला तत्व नहीं है ...

←§┐┬‹ζ⊟ι

... फिर प्रिंट करें ┐या ┬इस पर निर्भर करें कि यह सूची में अंतिम तत्व है ...

Ｗ⁼ＫＫψ←─

... और ─इस स्तर पर पिछली प्रविष्टि को भरने के लिए पर्याप्त प्रिंट करें ...

≔⁰ι»

... और जब हम यहां काम कर रहे हैं, तब तक लूप से बाहर आने के लिए वेरिएबल को क्लियर करना।

¿⊟ι┌¶┴

अन्यथा यदि यह (पहले तत्व) एक बहु-तत्व सूची है, तो इस स्तर के माता-पिता से निपटने ┌┴के ┴लिए ऊपर के कर्सर को छोड़कर, प्रिंट करें ।

¦│

अन्यथा अगर यह एक 1-तत्व सूची है, तो बस एक प्रिंट करें │और इस स्तर के माता-पिता से निपटने के लिए एक पंक्ति ऊपर ले जाएं।