एक बाइनरी ट्री बैलेंस्ड है, यह जांचने के लिए सबसे छोटा प्रोग्राम लिखें

Question

एक संतुलित बाइनरी ट्री में प्रत्येक नोड के लिए, बाएं चाइल्ड सबट्री और राइट चाइल्ड सबट्री की ऊंचाइयों में अधिकतम अंतर 1 है।

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

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

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

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

निम्नलिखित बाइनरी पेड़ हैं और एक रिपोर्ट है कि वे संतुलित हैं या नहीं:

ऊपर का पेड़ असंतुलित है ।

उपरोक्त पेड़ संतुलित है ।

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

इनपुट

एक बाइनरी ट्री की जड़। यह रूट ऑब्जेक्ट के संदर्भ या यहां तक ​​कि एक सूची के रूप में हो सकता है जो एक बाइनरी ट्री का एक वैध प्रतिनिधित्व है।

उत्पादन

सत्य मूल्य लौटाता है: यदि पेड़ संतुलित है

रिटर्न falsey मूल्य: पेड़ है संयुक्त राष्ट्र संतुलित।

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

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

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

typedef struct T
{
   struct T *l;
   struct T *r;
   int v;
}T;

यदि बाइनरी ट्री के लिए सूची प्रतिनिधित्व का उपयोग किया जाता है, तो यह निम्नलिखित की तरह लग सकता है:

[root_value, left_node, right_node]

Comments

खाली पेड़ हो सकता है इनपुट?

— tsh

एक पेड़ के अपने प्रारंभिक उदाहरण में, यदि आप पत्ती को हटाते हैं, तो क्या 4शेष पेड़ संतुलित है?

— नील

नहीं, यह उदाहरण नहीं है, मेरा मतलब एएससीआईआई कला का उपयोग करके प्रारंभिक एक था।

— नील

मेरे स्वयं के कार्यान्वयन "सी, 117 बाइट्स" के अनुसार: नहीं, चूंकि "5" से शुरू होने वाले दाहिने उपवर्म के पेड़ की ऊंचाई 2 है और बाएं उपनगर के पेड़ की ऊंचाई 0. है

— टी। सलीम

संपादन कम से कम 6 वर्ण हैं, लेकिन कृपया 'संतुलित' और 'बाइनरी' के बीच से अल्पविराम को हटा दें - 'बाइनरी ट्री' एक संज्ञा वाक्यांश है, इसलिए 'संतुलित, बाइनरी ट्री' लिखना 'लाल, स्नो मोबाइल' के बराबर है - अल्पविराम की आवश्यकता नहीं है।

— गीज़ा केर्केसेनी

Answer 1

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

ḊµŒḊ€IỊ;߀Ạ

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

खाली पेड़ का प्रतिनिधित्व किया जाता है []।

Comments

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

— टी। सलीम

बधाई हो एरिक आउटगोल्फ, आप विजेता हैं।

— टी। सलीम

Answer 2

प्रोलॉग (एसडब्ल्यूआई) , 49 बाइट्स

N+_/B/C:-X+B,Y+C,abs(X-Y)<2,N is max(X,Y)+1.
0+e.

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

पेड़ों का प्रतिनिधित्व करता है Value/Left_Child/Right_Child, जैसे कि खाली पेड़ परमाणु है e। परिभाषित करता है +/2, जो सफलता या विफलता के माध्यम से आउटपुट करता है , एक अनबाउंड चर (या पहले से ही पेड़ की ऊंचाई के बराबर) बाईं तरफ और दाईं ओर पेड़ - अगर ऊंचाई तर्क अस्वीकार्य है, तो परिभाषित करने के लिए 9 बाइट्स जोड़ें -T:-_+T.।

N + _/B/C :-            % If the second argument is a tree of the form _Value/B/C,
    X+B,                % X is the height of its left child which is balanced,
    Y+C,                % Y is the height of its right child which is balanced,
    abs(X-Y) < 2,       % the absolute difference between X and Y is strictly less than 2,
    N is max(X,Y)+1.    % and N is the height of the full tree.
0 + e.                  % If, on the other hand, the second argument is e, the first is 0.

Comments

(यदि प्रत्येक नोड का मान इनपुट से छोड़ा जा सकता है, तो _/-2 बाइट्स के लिए बाहर निकाला जा सकता है।)

— असंबंधित स्ट्रिंग

Answer 3

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

f@_[x_,y_]:=f@x&&f@y&&-2<Depth@x-Depth@y<2;f@_=1>0

Nullनल के लिए, value[left, right]नोड्स के लिए उपयोग करें । उदाहरण के लिए, निम्नलिखित पेड़ के रूप में लिखा गया है 2[7[2[Null, Null], 6[5[Null, Null], 11[Null, Null]]], 5[Null, 9[4[Null, Null], Null]]]।

    2
   / \
  7   5
 / \   \
2   6   9
   / \  /
  5  11 4

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

Comments

यह वास्तव में सुंदर है!

— ग्रेग मार्टिन

Answer 4

पायथन 3.8 (प्री-रिलीज़) , 133 125 बाइट्स

b=lambda t:((max(l[0],r[0])+1,abs(l[0]-r[0])<2)if(l:=b(t[1]))[1]and(r:=b(t[2]))[1]else(0,0))if t else(0,1)
h=lambda t:b(t)[1]

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

"सूची" प्रारूप में एक पेड़ लेता है: एक नोड के [value, left, right]साथ leftऔर rightनोड्स है।

समारोह में शामिल हों h।

लौटता है 0या Falseअसंतुलित पेड़ के लिए। लौटता है 1या Trueएक संतुलित पेड़ के लिए।

Ungolfed:

# Returns tuple (current height, subtrees are balanced (or not))
def balanced(tree):
  if tree: # [] evaluates to False
    left = balanced(tree[1])
    right = balanced(tree[2])
    # If  the subtrees are not both balanced, nothing to do, just pass it up
    if left[1] and right[1]:
      height = max(left[0], right[0]) + 1
      subtrees_balanced = abs(left[0] - right[0]) < 2
    else:
      height = 0 # Value doesn't matter, will be ignored
      subtrees_balanced = False
  else:
    height = 0
    subtrees_balanced = True
  return (height, subtrees_balanced)

def h(tree):
  return balanced(tree)[1]

-10: notएस से छुटकारा पाने के लिए उलटा तर्क

यदि कॉल के बीच में तर्क देने की अनुमति है, तो इसे (115 बाइट्स) छोटा किया जा सकता है

(b:=lambda t:((max(l[0],r[0])+1,abs(l[0]-r[0])<2)if(l:=b(t[1]))[1]and(r:=b(t[2]))[1]else(0,0))if t else(0,1))(_)[1]

_जाँच करने के लिए पेड़ होने के साथ ।

Answer 5

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

h=([l,r])=>l?(d=h(l)-h(r))*d<2?1+h(d>0?l:r):NaN:1

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

-9 बर्न अरनौल द्वारा।

---

जावास्क्रिप्ट, 58 बाइट्स

h=([l,r])=>l?(l=h(l),r=h(r),m=l>r?l:r,m+m-l-r<2?m+1:NaN):1

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

[]नल के लिए, और [left, right, value]नोड्स के लिए उपयोग करें ।

Answer 6

जावास्क्रिप्ट, 162 बाइट्स

f=x=>{for(f=0,s=[[x,1]];s[0];){if(!((d=(t=s.pop())[0]).a&&d.b||f))f=t[1];if(f&&t[1]-f>1)return 0;if(d.a)s.push([d.a,t[1]+1]);if(d.b)s.push([d.b,t[1]+1])}return 1}

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

इनपुट का प्रारूप एक वस्तु है

root={a:{node},b:{node},c:value}

व्याख्या

for(f=0,s=[[x,1]];s[0];){if(!((d=(t=s.pop())[0]).a&&d.b||f))f=t[1]

चौड़ाई प्रदर्शन पहली खोज में पहले नोड की गहराई का पता चलता है जो एक या अधिक शाखाओं को याद कर रहा है।

if(f&&t[1]-f>1)return 0;if(d.a)s.push([d.a,t[1]+1]);if(d.b)s.push([d.b,t[1]+1])}

चौड़ाई पहली खोज जारी रखते हुए, शून्य वापस लौटें यदि कोई तत्व पहले नोड लापता शाखाओं की गहराई से दो गहरा है।

return 1}

यदि ऐसा कोई नोड नहीं मिला है, तो 1 वापस करें

Comments

शायद पहले से बेहतर खोज करने के लिए कुछ तरीका है, लेकिन मैं इसके बारे में सोच भी नहीं सकता था।

— f --n 20:tɪk

मुझे लगता है कि यह कुछ मान्य मामलों के लिए विफल रहता है जैसे कि पहला उदाहरण जो पत्ती को हटाते समय संतुलित हो जाना चाहिए 4।

— नील

Answer 7

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

f(t)=t!=()&&(-(f.(t.c)...)^2<2 ? maximum(f,t.c)+1 : NaN)

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

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

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

मिथ्या मूल्य है NaN, कोई भी पूर्णांक सत्य है।

Comments

एन्कोडिंग मान लिया जाये कि UTF-8 यह वास्तव में 57 की वजह से बाइट्स है, ≢, के अनुसार TIO के अंतर्निहित बाइट काउंटर । किसी भी तरह, तटरक्षक और सीसी में आपका स्वागत है!

— असंबंधित स्ट्रिंग

हाँ तुम सही हो। मैंने इसे सही किया, ताकि यह अब वास्तव में 56 बाइट्स हो

— user3263164

Answer 8

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

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

कहाँ पे

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

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

Answer 9

सी, 117 बाइट्स

h(T*r){r=r?1+h(h(r->l)>h(r->r)?r->l:r->r):0;}b(T*r){return r->l&&!b(r->l)||r->r&&!b(r->r)?0:abs(h(r->l)-h(r->r))<=1;}

संरचना कार्यान्वयन निम्नलिखित है:

 typedef struct T
    {
        struct T * l;

        struct T * r;

        int v;

    } T;

JDoodle पर यह कोशिश करो

Comments

यह 117 बाइट्स प्रतीत होता है, हालांकि आप <2इसके बजाय उस अंतिम जांच के लिए कर सकते हैं

— जो किंग

इसके अलावा, मुझे यकीन नहीं है कि यह कितना वैध है, क्योंकि यह सबमिशन से बाहर परिभाषित एक डेटा संरचना पर निर्भर करता है

— जो किंग

Answer 10

पायथन 2 , 99 96 94 बाइट्स

lambda A:A==[]or(abs(D(A[1])-D(A[2]))<2)*f(A[1])*f(A[2])
D=lambda A:A>[]and-~max(map(D,A[1:]))

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

जो राजा से 3 बाइट्स ।

इनपुट के रूप में लेता है: खाली नोड है [], और अन्य नोड हैं [<value>, <leftNode>, <rightNode>]। 0/1झूठा / सच के लिए आउटपुट ।