18

बाइनरी ट्री की ऊंचाई रूट नोड से नोड बच्चे तक की दूरी है जो रूट से सबसे दूर है।

नीचे एक उदाहरण है:

           2 <-- root: Height 1
          / \
         7   5 <-- Height 2
        / \   \
       2   6   9 <-- Height 3
          / \  /
         5  11 4 <-- Height 4

बाइनरी ट्री की ऊँचाई: 4

एक बाइनरी ट्री की परिभाषा

एक पेड़ एक वस्तु है जिसमें एक हस्ताक्षरित पूर्णांक मान होता है और या तो दो अन्य पेड़ या उन्हें इंगित करते हैं।

बाइनरी ट्री स्ट्रक्चर की संरचना कुछ इस तरह दिखती है:

typedef struct tree
{
  struct tree * l;

  struct tree * r;

  int v;

} tree;

चुनौती:

इनपुट

एक बाइनरी ट्री की जड़

उत्पादन

वह संख्या जो एक बाइनरी ट्री की ऊंचाई का प्रतिनिधित्व करती है

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

code-golf binary-tree

— टी। सलीम
स्रोत

4

पॉइंटर्स के बिना भाषाएं क्या लेती हैं?

— जोनाथन एलन

4

... लेकिन तब मेरी ट्री ऑब्जेक्ट सिर्फ एक प्रॉपर्टी हो सकती थी, कहो h। इस चुनौती के उद्देश्य के लिए सूचियों से बनी विशिष्ट संरचना को परिभाषित करना बेहतर हो सकता है।

— जोनाथन एलन

11

@ T.Salim भविष्य में, कृपया सैंडबॉक्स में पोस्ट करने पर विचार करें ।

— wizzwizz4

1

तो, क्या एक वैध प्रतिनिधित्व लंबाई 3 की सूची है [root_value, left_node, right_node]जहां प्रत्येक left_nodeऔर right_nodeबाइनरी पेड़ स्वीकार्य हैं? यह कई भाषाओं में तुच्छ होगा, लेकिन कुछ अन्य लोगों में यह मजेदार हो सकता है।

— जोनाथन एलन

3

क्या आप इस सवाल को संपादित कर सकते हैं कि एक वैध बाइनरी संरचना का गठन क्या है? शायद जैसी परिभाषा a tree is an object that contains a value and either two other trees or pointers to them। एक परिभाषा जो वस्तुओं के बिना भाषाओं को शामिल करती है वह भी अच्छी होगी।

— जो किंग

11

जेली , 3 बाइट्स

ŒḊ’

पेड़ को दर्शाने वाली एक सूची को स्वीकार करने वाला एक मोनडिक लिंक: [root_value, left_tree, right_tree]जहां प्रत्येक left_treeऔर right_treeसमान संरचनाएं (यदि आवश्यक हो तो खाली हो), जो ऊंचाई को जन्म देती है।

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

कैसे?

जेली में सुंदर तुच्छ:

ŒḊ’ - Link: list, as described above
ŒḊ  - depth
  ’ - decremented (since leaves are `[value, [], []]`)

— जोनाथन एलन
स्रोत

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

— टी। सलीम

4

शीर्ष लेख में लिंक पर क्लिक करें - यह डेनिस द्वारा विकसित एक गोल्फिंग भाषा है , जो साइट के मध्यस्थों में से एक है।

— जोनाथन एलन

2

मुझे आश्चर्य है कि xइसके बजाय एक पत्ती का प्रतिनिधित्व करने के लिए यह कितना विवादास्पद होगा [x, [], []]...

— एलिक आउटफोलर

@EriktheOutgolfer प्रश्न के "पॉइंटर" और "संरचित" प्रकृति के साथ रखने के लिए मुझे लगता है कि प्रत्येक नोड को एक ही फॉर्म का होना चाहिए।

— जोनाथन एलन

10

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

एक निरीक्षण और 4 बचत के लिए Arnauld के लिए धन्यवाद।

f=lambda a:a>[]and-~max(map(f,a))

एक पुनरावर्ती कार्य जो पेड़ का प्रतिनिधित्व करने वाली एक सूची को स्वीकार करता है: [root_value, left_tree, right_tree]जहां प्रत्येक left_treeऔर right_treeसमान संरचनाएं हैं (यदि आवश्यक हो तो खाली हो), जो ऊंचाई लौटाता है।

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

^{ध्यान दें कि []वापस आ जाएगा False, लेकिन पायथन में False==0।}

— जोनाथन एलन
स्रोत

एक ही व्यक्ति को एक ही प्रश्न के दो अलग-अलग उत्तर देने की अनुमति है?

— टी। सलीम

6

हाँ, ज़ाहिर है, गोल्फ एक भाषा स्तर पर एक प्रतियोगिता है। यहां तक कि एक ही भाषा में दूसरी प्रविष्टि कभी-कभी स्वीकार्य होती है, यदि दृष्टिकोण बहुत अलग है।

— जोनाथन एलन

@Arnauld ऐसा लगता है (मुझे लगता है कि गैर-पूर्णांक किसी कारण के लिए मौजूद हो सकते हैं)

— जोनाथन एलन

6

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

h L=0 
h(N l r _)=1+max(h l)(h r)

कस्टम ट्री प्रकार का उपयोग करना data T = L | N T T Int, जो चुनौती में दी गई सी संरचना के बराबर हास्केल है।

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

— nimi
स्रोत

6

पर्ल 6 , 25 बाइट्स

{($_,{.[*;*]}...*eqv*)-2}

इनपुट एक 3-तत्व सूची है (l, r, v) । खाली पेड़ खाली सूची है।

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

व्याख्या

{                       }  # Anonymous block
    ,        ...  # Sequence constructor
  $_  # Start with input
     {.[*;*]}  # Compute next element by flattening one level
               # Sadly *[*;*] doesn't work for some reason
                *eqv*  # Until elements doesn't change
 (                   )-2  # Size of sequence minus 2

पुराना घोल, 30 बाइट्स

{+$_&&1+max map &?BLOCK,.[^2]}

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

— nwellnhof
स्रोत

&?BLOCKचाल दिलचस्प है, लेकिन यह एक है बाइट्स के छोटे जोड़ी $ करने के लिए ब्लॉक आवंटित करने के लिए!

— जो किंग

@ मुझे पता नहीं है। चुनौती के समाधान को एक अस्थिर वैश्विक में संग्रहीत करना जैसे कि $!या $/मुझे धोखा देने जैसा लगता है।

— nwellnhof

(Ab) $ जैसे चर का उपयोग करना! और $ 6, गोल्फिंग P6 के लिए काफी मानक अभ्यास है।

— user0721090601

6

05AB1E , 11 7 5 बाइट्स

Δ€`}N

-4 बाइट्स @ExpiredData के लिए धन्यवाद ।
-2 बाइट्स @Grimy को धन्यवाद ।

इनपुट प्रारूप जेली उत्तर के समान है: पेड़ का प्रतिनिधित्व करने वाली एक सूची:, [root_value, left_tree, right_tree]जहां प्रत्येक left_treeऔर right_treeसमान संरचनाएं (वैकल्पिक रूप से खाली) हैं। Ie [2,[7,[2,[],[]],[6,[5,[],[]],[11,[],[]]]],[5,[],[9,[4,[],[]],[]]]]चुनौती विवरण से पेड़ का प्रतिनिधित्व करता है।

इसे ऑनलाइन आज़माएं या कुछ और परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

Δ     # Loop until the (implicit) input-list no longer changes:
  €`  #  Flatten the list one level
}N    # After the loop: push the 0-based index of the loop we just finished
      # (which is output implicitly as result)

ध्यान दें कि यद्यपि 05AB1E 0-आधारित है, परिवर्तन-लूप Δआउटपुट इंडेक्स को सही बनाता है , क्योंकि इसे अब और परिवर्तन के लिए अतिरिक्त पुनरावृत्ति की आवश्यकता है।

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

1

7 बाइट्स?

— समय सीमा समाप्त डेटा

@ExpiredData आह, बिल्कुल .. धन्यवाद! :)

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

1

5 बाइट्स

— ग्रैमी

@ ग्रेमी ने सोचा कि एक लूप के बाहर इंडेक्स का उपयोग करने से केवल विरासत कोड में काम होता है ..: S धन्यवाद!

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

5

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

इनपुट संरचना: [[left_node], [right_node], value]

f=([a,b])=>a?1+f(f(a)>f(b)?a:b):0

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

टिप्पणी की गई

f =                       // f is a recursive function taking
([a, b]) =>               // a node of the tree split into
                          // a[] = left child, b[] = right child (the value is ignored)
  a ?                     // if a[] is defined:
    1 +                   //   increment the final result for this branch
    f(                    //   and add:
      f(a) > f(b) ? a : b //     f(a) if f(a) > f(b) or f(b) otherwise
    )                     //
  :                       // else:
    0                     //   stop recursion and return 0

— Arnauld
स्रोत

लगता है जैसे आप एक बाइट को बचा सकते हैं a&&-~।

— झबरा

1

@ शैगी कि अपरिभाषित के साथ तुलना करने के लिए नेतृत्व करेंगे ।

— अरण्युलद

4

सी, 43 बाइट्स

h(T*r){r=r?1+(int)fmax(h(r->l),h(r->r)):0;}

बाइनरी ट्री की संरचना निम्नलिखित है:

typedef struct tree
{
  struct tree * l;

  struct tree * r;

  int v;

} tree;

— टी। सलीम
स्रोत

2

55 बाइट्स इसे ऑनलाइन आज़माएं! कुछ सी-विशिष्ट गोल्फिंग ट्रिक्स यहाँ हैं!

— एरिकाफ

1

@ErikF या 45 बाइट्स

— Arnauld

2

43 बाइट्स

— nwellnhof

3

यदि आपका सबमिशन झंडे पर निर्भर करता है, तो क्या आप उन्हें अपने सबमिशन के हेडर में जोड़ सकते हैं?

— जो किंग

1

बिल्डिंग @nwellnhof 42 बाइट्स

— सीलिंगकैट

4

जावास्क्रिप्ट (Node.js) , 32 बाइट्स

f=a=>/,,/.test(a)&&f(a.flat())+1

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

~~के flatबजाय नाम का उपयोग करना flattenया smooshकोड गोल्फ के लिए एक महान विचार है।~~

[]पेड़ में नल नोड के [left, right, value]लिए और नोड्स के लिए उपयोग करना । valueयहाँ एक पूर्णांक है।

— TSH
स्रोत

4

वोल्फ्राम भाषा (गणितज्ञ) , 10 बाइट्स

Depth@#-2&

इसे ऑनलाइन आज़माएं! एक नेस्टेड सूची के रूप में इनपुट लेता है {v, l, r}।

— LegionMammal978
स्रोत

यदि 2[7[2,6[5,11]],5[9[4,],]]पेड़ का एक वैध प्रतिनिधित्व है, तो Depthकाम करता है

— बजे

3

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

निम्नलिखित डेटा परिभाषा का उपयोग करना:

data T a = (:&) a [T a]

ऊंचाई है:

h(_:&x)=foldr(max.succ.h)0 x

— माइकल क्लेन
स्रोत

2

स्कीम, 72 बाइट्स

(define(f h)(if(null? h)0(+ 1(max(f(car(cdr h)))(f(car(cdr(cdr h))))))))

अधिक पठनीय संस्करण:

(define (f h)
   (if (null? h)
      0
      (+ 1 
         (max
             (f (car (cdr h)))
             (f (car (cdr (cdr h))))
         )
      )
   )
)

किसी पेड़ का प्रतिनिधित्व करने के लिए फ़ॉर्म (डेटा, बाएं, दाएं) की सूचियों का उपयोग करना। उदाहरण के लिए

   1
  / \
  2  3
 /\
 4 5

is represented as: (1 (2 (4 () ()) (5 () ())) (3 () ())

(1
   (2
      (4 () ())
```   (5 () ())
   (3 () ())
)

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

— जाचरी कपास
स्रोत

2

आर , 51 बाइट्स

function(L){while(is.list(L<-unlist(L,F)))T=T+1;+T}

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

इनपुट: प्रारूप में एक नेस्टेड सूची:list(ROOT_ELEMENT, LEFT_TREE, RIGHT_TREE)
एल्गोरिदम: Iteratively पेड़ को एक स्तर तक समतल करता है जब तक कि यह एक सपाट वेक्टर न हो जाए: पुनरावृत्तियों की गिनती अधिकतम गहराई से मेल खाती है।

@ केविनक्रूजसेन समाधान से प्रेरित

पुनरावर्ती विकल्प:

आर , 64 बाइट्स

`~`=function(L,d=0)'if'(is.list(L),max(L[[2]]~d+1,L[[3]]~d+1),d)

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

फ़ंक्शन / ऑपरेटर को फिर से परिभाषित करता है '~' को पुनर्परिभाषित करता है जो सूची संरचना में संग्रहीत पेड़ की अधिकतम गहराई की गणना करने में सक्षम बनाता है।

एक पेड़ की सूची संरचना प्रारूप में है: list(ROOT_ELEMENT, LEFT_TREE, RIGHT_TREE)

-2 @Giuseppe को धन्यवाद

— digEmAll
स्रोत

तुम क्यों प्रयोग करते हैं d=1और फिर d-1अंत में? क्या आप शुरू नहीं कर सकते 0?

— गिउसेप्पे

इसके अलावा, मैं बंद >करने के लिए ~ यहां तो परीक्षण मामलों इनपुट करने के लिए आसान है

— ग्यूसेप

@Giuseppe: बेशक ... मुझे स्पष्ट याद आ रहा था

— digEmAll

1

जाप , 8 बाइट्स

@eU=c1}a

कोशिश करो

मूल, 9 बाइट्स

Î©¡ÒßXÃrw

कोशिश करो

— झबरा
स्रोत

1

के (ngn / k) , 4 बाइट्स

समाधान:

#,/\

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

स्पष्टीकरण:

मुझे लगता है कि मैं इस बिंदु को याद कर सकता हूं।

3-आइटम सूची (पैरेंट-नोड; लेफ्ट-चाइल्ड; राइट-चाइल्ड) के रूप में एक पेड़ का प्रतिनिधित्व करते हुए, उदाहरण के रूप में प्रस्तुत किया जा सकता है

(2;
  (7;
    (,2);
    (6;
      (,5);
      (,11)
    )
  );
  (5;
    ();
    (9;
      (,4);
      ()
    )
  )
)

या: (2;(7;(,2);(6;(,5);(,11)));(5;();(9;(,4);())))।

तो इसका समाधान पुनरावृत्तियों को पुनरावृत्त करना है, और पुनरावृत्तियों की गणना करना है:

#,/\ / the solution
   \ / iterate
 ,/  / flatten
#    / count

— streetster
स्रोत

0

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

⊞θ⁰⊞υθＦυ«≔⊕⊟ιθＦΦι∧κλ⊞υ⊞Ｏκθ»Ｉθ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। प्रसंस्करण के दौरान अस्थायी रूप से पेड़ को संशोधित करता है। स्पष्टीकरण:

⊞θ⁰

शून्य को रूट नोड में पुश करें।

⊞υθ

सभी नोड्स की सूची में रूट नोड पुश करें।

Ｆυ«

वृक्ष की चौड़ाई की पहली खोज करें।

≔⊕⊟ιθ

इस नोड की गहराई प्राप्त करें।

ＦΦι∧κλ

किसी भी बच्चे के नोड्स पर लूप।

⊞υ⊞Ｏκθ

बच्चे को उसके माता-पिता की गहराई को बताएं और उसे सभी नोड्स की सूची में धकेल दें।

»Ｉθ

एक बार जब सभी नोड्स पिछले नोड की गहराई का पता लगा लेते हैं। चूंकि ट्रैवर्सल पहले चौड़ाई था, यह पेड़ की ऊंचाई होगी।

— नील
स्रोत

0

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

▐▌µ╡⌂

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

स्टैक्स में न तो पॉइंटर्स हैं और न ही शून्य मान हैं, इसलिए मैं इनपुट का प्रतिनिधित्व करता हूं [2,[7,[2,[],[]],[6,[5,[],[]],[11,[],[]]]],[5,[],[9,[4,[],[]],[]]]] । हो सकता है कि यह एक अनुचित लाभ है, लेकिन यह मेरे निकटतम था।

अनपैक्ड, अनगॉल्फ्ड और टिप्पणी की गई, कोड इस तरह दिखता है।

        The input starts on top of the input stack
Z       Tuck a zero underneath the top value in the stack.  Both values end up on the main stack.
D       Drop the first element from array
F       For each remaining element (the leaves) run the rest of the program
  G^    Recursively call the entire program, then increment
  T     Get maximum of the two numbers now ow the stack

इसको चलाओ

— पुनरावर्ती
स्रोत

0

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

val Tree.h:Int get()=1+maxOf(l?.h?:0,r?.h?:0)

निम्न वर्ग मान लिया गया है

class Tree(var v: Int, var l: Tree? = null, var r: Tree? = null)

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

— एसो लियो
स्रोत

0

जूलिया, 27 बाइट्स

f(t)=t≢()&&maximum(f,t.c)+1

बाइनरी ट्री का प्रतिनिधित्व करने वाली निम्न संरचना के साथ:

struct Tree
    c::NTuple{2,Union{Tree,Tuple{}}}
    v::Int
end

cएक ट्यूपल बाएं और दाएं नोड्स का प्रतिनिधित्व करता है और खाली ट्यूपल ()का उपयोग नोड की अनुपस्थिति को इंगित करने के लिए किया जाता है।

— user3263164
स्रोत

0

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

fun N.c():Int=maxOf(l?.c()?:0,r?.c()?:0)+1

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

कहाँ पे

data class N(val l: N? = null, val r: N? = null, val v: Int = 0)

— Brojowski
स्रोत

बाइनरी ट्री की ऊंचाई की गणना करने के लिए सबसे छोटा कार्यक्रम लिखें

जेली , 3 बाइट्स

कैसे?

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

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

पर्ल 6 , 25 बाइट्स

व्याख्या

पुराना घोल, 30 बाइट्स

05AB1E , 11 7 5 बाइट्स

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

टिप्पणी की गई

सी, 43 बाइट्स

जावास्क्रिप्ट (Node.js) , 32 बाइट्स

वोल्फ्राम भाषा (गणितज्ञ) , 10 बाइट्स

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

स्कीम, 72 बाइट्स

आर , 51 बाइट्स

आर , 64 बाइट्स

जाप , 8 बाइट्स

मूल, 9 बाइट्स

के (ngn / k) , 4 बाइट्स

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

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

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

जूलिया, 27 बाइट्स

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