पृष्ठभूमि

एक द्विआधारी वृक्ष एक जड़ वाला पेड़ है जिसके प्रत्येक नोड में अधिकतम दो बच्चे हैं।

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

एक BST (बाइनरी सर्च ट्री) एक लेबल बाइनरी ट्री है, जिसमें प्रत्येक नोड का लेबल उसके बाएं सबट्री के सभी नोड्स के लेबल से अधिक होता है, और इसके सही सबट्री में सभी नोड्स के लेबल से छोटा होता है। उदाहरण के लिए, निम्नलिखित एक BST है:

प्री-ऑर्डर ट्रेवर्सल एक लेबल द्विआधारी पेड़ के निम्नलिखित छद्म कोड द्वारा परिभाषित किया गया है।

function preorder(node)
    if node is null then
        return
    else
        print(node.label)
        preorder(node.left)
        preorder(node.right)

बेहतर अंतर्ज्ञान प्राप्त करने के लिए निम्न छवि देखें:

इस बाइनरी ट्री के कोने निम्नलिखित क्रम में छपे हैं:

F, B, A, D, C, E, G, I, H

आप BSTs के बारे में अधिक पढ़ सकते हैं यहाँ और अधिक के बारे में प्री-ऑर्डर ट्रेवर्सल, और यहाँ ।

चुनौती

पूर्णांकों की एक सूची को देखते हुए , अपने कार्य को निर्धारित करने के लिए एक BST जिसका प्री-ऑर्डर ट्रेवर्सल प्रिंट वास्तव में है या नहीं है । $a$ $a$

इनपुट

एक गैर खाली सूची अलग धनात्मक पूर्णांक के । $a$
वैकल्पिक रूप से, की लंबाई । $a$

उत्पादन

एक truthy मूल्य अगर कुछ BST की प्री-ऑर्डर ट्रेवर्सल है। $a$
एक गलत मूल्य अन्यथा।

नियम

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

उदाहरण

Input                   ---->   Output

[1]                     ---->   True
[1,2,3,4]               ---->   True
[5,1,4,2,3]             ---->   True
[5,4,3,2,1,6,7,8,9]     ---->   True
[4,2,1,3,6,5,7]         ---->   True
[8,3,1,6,4,7,10,14,13]  ---->   True
[2,3,1]                 ---->   False
[6,3,2,4,5,1,8,7,9]     ---->   False
[1,2,3,4,5,7,8,6]       ---->   False
[3,1,4,2]               ---->   False

उदाहरणों पर एक दृश्य देखने के लिए इस लिंक ( केविन क्रूज़सेन के सौजन्य से ) की जाँच करें ।

code-golf decision-problem binary-tree

— Delfad0r
स्रोत

1

यहाँ परीक्षण के मामलों के एक अतीत के दृश्य के रूप में वे कैसे सत्य / असत्य हैं के लिए अधिक दृश्य दिखते हैं। मेरे लिए अच्छा चुनौती btw, +1।

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

क्या हम मान सकते हैं कि सभी पूर्णांक सकारात्मक हैं?

— जीबी

@ जीबी हां। मैं अब पोस्ट को संपादित करूंगा।

— Delfad0r

11

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

a=>!a.some((p,i)=>a.some((q,j)=>q>p&a[j+=j>i]<p))

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

तथ्य यह है कि सरणी के लिए उपयोग करना , कुछ BST iff की प्री-ऑर्डर ट्रेवर्सल है धारण करता है। $a_0 ... a_{n-1}$ $a$ $\forall 0\le i<j<n; a_i<a_{j-1} \implies a_i<a_j$

Arnauld के लिए धन्यवाद , 1 बाइट बचाएं।

— TSH
स्रोत

8

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

ŒPŒ¿€4ḟ

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

[4]ट्रैवर्सल्स के लिए रिटर्न , अन्यथा []।

टीश के एल्गोरिथ्म का अनिवार्य रूप से उपयोग करता है: पूर्व-क्रम के ट्रैवर्सल के लिए "अयोग्य" स्थिति 3 तत्वों का एक अनुवर्ती है जो [मध्य, उच्च, निम्न] जैसा दिखता है । (उदाहरण के लिए, [२०, ३०, १०])

हम समतुल्य रूप से किसी subsequences के लिए जाँच किसी भी सूचकांक है लंबाई 4 उनकी क्रमचय सूचियों में है, जो सभी सूचियों की तरह हल कर रहे हैं [एक ₁ ... एक _{कश्मीर} CDB] जहां एक _मैं हल कर रहे हैं और एक _मैं <b <ग <घ । (यदि हम अंतिम तीन तत्वों को देखते हैं तो ऐसी प्रत्येक सूची अयोग्य है, और प्रत्येक अयोग्य सूची स्पष्ट रूप से इस रूप में है)

ŒP          All subsequences.
  Œ¿€       Permutation index of each.
     4ḟ     Set difference of {4} and this list.

प्रमाण

प्री-ऑर्डर ट्रैवर्सल में कोई अयोग्य अनुवर्ती शामिल नहीं है

आधार मामला: ट्रैवर्सल (•) खाली सूची है। ✓

इंडक्शन: ट्रैवर्सल (t) है: t.root ++ ट्रैवर्सल (t.left) ++ ट्रैवर्सल (t.right) ।

चलो [क, ख, ग] किसी परिणाम को इससे हो। हम दिखा देंगे c <a b असंभव है।

यदि t.root = a , तो c <a b के लिए c ∈ t.left और b। T.right की आवश्यकता होती है , इसलिए [a, b, c] गलत क्रम है।

यदि a, b, c। T.left या a, b, c right t.right , इंडक्शन परिकल्पना का उपयोग करें।

यदि। T.left और c right t.right है तो c> a ।

बाद के अयोग्य घोषित किए बिना अलग पूर्णांकों की एक सूची एक BST का पूर्व-क्रम अनुक्रमणिका है

यदि सूची खाली है, तो यह तुच्छ BST • का त्रैमासिक है।

यदि सूची में पूंछ के बाद सिर है :
चलो कम से सबसे लंबे उपसर्ग हो पूंछ से कम तत्वों के सिर , और अधिक सूची के बाकी हो।

फिर अधिक [1]> सिर , और अन्य सभी अधिक [i] सिर से भी अधिक हैं (अन्यथा [सिर, अधिक [1], अधिक [i] एक अयोग्य परिणाम होगा)।

पुनर्खरीद: BSTs में कम और अधिक बारी ।
अब हमारी सूची का ट्रैवर्सल है
                 head
                /    \
         BST(less)   BST(more),
और यह पेड़ एक मान्य बीएसटी है।

— लिन
स्रोत

1

अच्छा सबूत। वास्तव में जब मैंने उत्तर पोस्ट किया तो मैंने फॉर्मूला साबित नहीं किया। मुझे लगा कि इनपुट से BST के निर्माण के कुछ प्रयासों के बाद यह सही है।

— tsh

5

जावा 10, 94 बाइट्स

a->{var r=0>1;for(int j=a.length-1,i;j-->0;)for(i=0;i<j;)r|=a[j]>a[i]&a[j+1]<a[i++];return!r;}

पोर्ट ऑफ @tsh 'जावास्क्रिप्ट जवाब ।

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

स्पष्टीकरण:

a->{                      // Method with integer-array parameter and boolean return-type
  var r=0>1;              //  Result-boolean, starting at false
  for(int j=a.length-1,i;j-->0;)
                          //  Loop `j` in the range (length-1, 0]:
    for(i=0;i<j;)         //   Inner loop `i` in the range [0, j):
      r|=                 //    If any are true, change the result to true as well:
         a[j]>a[i]        //     The `j`'th item is larger than the `i`'th item
         &a[j+1]<a[i++];  //     And the `j+1`'th item is smaller than the `i`'th item
  return!r;}              //  After the nested loop, check if the boolean is still false

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

1

टीआईएल है कि जावा बूलियंस के साथ फिर से असाइन किया जा सकता है |=। मुझे लगता है &=कि यह भी काम करेगा?

— जे। सल्ल।

@ J.Sallé हां, दोनों |=और &=के लिए शॉर्टकट के रूप में काम करते हैं b = b | conditionऔर b = b & condition(जहां &और |के लिए शॉर्टकट हैं &&और ||निश्चित रूप से अधिकांश मामलों में)।

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

5

रूबी , 46 40 38 बाइट्स

f=->r{a,*b=r;!a||b==b&[*0..a]|b&&f[b]}

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

यह पुनरावर्ती aरूप से पहले तत्व को एक धुरी के रूप में ले कर काम करता है , और जाँचता है कि क्या बाकी सरणी को दो में विभाजित किया जा सकता है (चौराहे और संघ का उपयोग करके: पहले सभी तत्वों को हटा दें> ए, फिर उन्हें फिर से दाईं ओर जोड़ें और जांचें कि क्या कुछ है बदला हुआ)।

— जीबी
स्रोत

3

रेटिना 0.8.2 , 31 बाइट्स

\d+
$*
M`\b((1+)1+,).*\1\2\b
^0

इसे ऑनलाइन आज़माएं! लिंक में परीक्षण के मामले शामिल हैं। @ Tsh के एल्गोरिथ्म का उपयोग करता है। स्पष्टीकरण:

\d+
$*

यूनीरी में बदलें।

M`\b((1+)1+,).*\1\2\b

उन संख्याओं का पता लगाएं जो दो बाद के लगातार अवरोही संख्याओं के बीच स्थित हैं।

^0

जांचें कि मैचों की संख्या शून्य है।

— नील
स्रोत

3

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

!*.combinations(3).grep:{[>] .[1,0,2]}

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

व्याख्या

 *.combinations(3)  # All combinations of 3 elements a,b,c
!                 .grep:{            }  # Return false if check succeeds for any combination
                         [>] .[1,0,2]   # Check whether b>a>c, that is b>a and c<a

— nwellnhof
स्रोत

3

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

f[]=1<3
f(x:r)|(a,b)<-span(<x)r=all(>x)b&&f a&&f b

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

— Laikoni
स्रोत

3

स्काला ( 68 67 बाइट्स)

def%(i:Seq[Int])= !i.combinations(3).exists(c=>c(0)<c(1)&c(0)>c(2))

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

पोर्ट ऑफ @ nwellnhof का जवाब ।

स्काला ( 122 103 बाइट्स)

def f(i:Seq[Int]):Boolean=if(i.size<1)1>0 else{val(s,t)=i.tail.span(_<i(0));t.forall(_>i(0))&f(s)&f(t)}

दोनों समाधानों को छोटा बनाने के सुझाव के लिए @Laikoni का धन्यवाद।

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

स्पष्टीकरण:

स्लाइस (स्केल का उपयोग करके span) ऐरे के सिर को स्लाइसिंग मानदंड के रूप में उपयोग करते हुए सरणी।
पुष्टि करें कि सरणी का पहला टुकड़ा सिर से कम है और दूसरा टुकड़ा सिर से बड़ा है।
पुनरावर्ती जाँच करें कि प्रत्येक टुकड़ा भी संतुष्ट करता है (2)

— jrook
स्रोत

1

मुझे लगता है कि आपको इसमें स्थान की आवश्यकता नहीं है val (s,t), trueहो सकता है 1>0और आप ड्रॉप कर सकते हैं s.forall(_<i(0))&क्योंकि यह पहले से ही बीमा होना चाहिए span।

— लकोनी

1

आप फंक्शन को कॉल कर सकते हैं %और स्पेस को छोड़ सकते हैं:def%(i:Seq[Int])=

— Laikoni

आपके समाधान में कुछ अन्य के विपरीत फ़ंक्शन की घोषणा शामिल है। शुद्ध भाव काफी छोटे हैं। ;)

— डॉ वाई विट

मैं टीश के उत्तर को पोर्ट करना चाह रहा था, लेकिन इसे पर्याप्त रूप से प्राप्त करने का प्रबंधन नहीं किया। संस्करण 1 l.zipWithIndex.foldLeft(1>0){case(r,v,i)=>r&l.zip(l.tail).slice(i+1,l.length).forall(x=>l(i)>x._1|l(i)<x._2)}.। संस्करण 2 (for(i<-l.indices)yield l.zip(l.tail).slice(i+1,l.length).forall(x =>l(i)>x._1|l(i)<x._2)).forall(x=>x).। किसी भी विचार कैसे इन छोटे बनाने के लिए?

— डॉ। वाई विट

सादे अंग्रेजी में एल्गोरिथ्म: प्रत्येक तत्व के लिए एक दूसरे के बगल में जाने वाले तत्वों के सभी जोड़े के साथ एक जांच करें।

— डॉ। वाई विट

2

05AB1E , 15 10 बाइट्स

ŒεD{3.IÊ}P

पोर्ट ऑफ @Lynn जेली उत्तर ।
-5 बाइट्स @Emigna की बदौलत ।

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

स्पष्टीकरण: "

Œ             # Take all sublists of the (implicit) input-list
              #  i.e. [2,3,1] → [[2],[2,3],[2,3,1],[3],[3,1],[1]]
              #  i.e. [1,2,3,4]
              #   → [[1],[1,2],[1,2,3],[1,2,3,4],[2],[2,3],[2,3,4],[3],[3,4],[4]]
 ε      }     # Map each to:
  D           #  Duplicate the current sublist on the stack
   {          #  Sort the copy
              #   i.e. [2,3,1] → [1,2,3]
              #   i.e. [2,3,4] → [2,3,4]
    3.I       #  Get the 4th (3rd 0-indexed) permutation of this list
              #   i.e. [1,2,3] → [2,3,1]
              #   i.e. [2,3,4] → [3,4,2]
       Ê      #  Check that the lists are NOT equal
              #   i.e. [2,3,1] and [2,3,1] → 0 (falsey)
              #   i.e. [2,3,4] and [3,4,2] → 1 (truthy)
         P    # Check whether all are truthy (and output implicitly)
              #  i.e. [1,1,0,1,1,1] → 0 (falsey)
              #  i.e. [1,1,1,1,1,1,1,1,1,1] → 1 (truthy)

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

1

कैसे के बारे में ŒεD{3.IÊ}P?

— एमिगॉन

1

@Eigna हाँ, यह वास्तव में बहुत आसान होगा ...>> धन्यवाद! :) (और एक अच्छा सप्ताहांत है।)

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

2

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

f(h:t)=t==[]||all(>h)(snd$span(<h)t)&&f t

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

लिन के अवलोकन का उपयोग करता है कि यह जांचने के लिए पर्याप्त है कि मध्य..हाई..लो के लिए कोई परिणाम नहीं है । इसका मतलब है कि प्रत्येक तत्व के लिए h, तत्वों की सूची tहै कि के बाद आता है तत्वों का एक ब्लॉक है <hतत्वों का एक ब्लॉक के बाद >h(दोनों ब्लॉकों खाली हो सकता है)। तो, कोड की जाँच करता है कि हम तत्वों का उपसर्ग ड्रॉप के बाद कि <hमें t, शेष तत्वों सब कर रहे हैं >h। पुनरावर्तन प्रत्येक प्रारंभिक तत्व के लिए यह जाँच करता है hजब तक कि सूची लंबाई 1 नहीं है।

एक संभावित सरलीकरण यह है कि यह उप- मध्य के लिए जाँच करने के लिए पर्याप्त है..उच्च, कम जहाँ पिछले दो लगातार हैं। दुर्भाग्य से, हास्केल के पास पिछले दो तत्वों को निकालने का एक छोटा तरीका नहीं है, जैसा कि सामने से एक पैटर्न मैच के साथ किया जा सकता है a:b:c। मुझे एक छोटा समाधान मिला जो मध्य, उच्च..लो के लिए जाँच करता है , लेकिन यह इनपुट्स को अस्वीकार करने में विफल रहता है [3,1,4,2]।

लाईकोनी से लिए गए प्रारूपित परीक्षण मामले ।

— XNOR
स्रोत

1

जाप , 14 बाइट्स

d@sY ð_§XÃxÈ-Y

जाप दुभाषिया

falseBST के लिए आउटपुट , trueबिना BST के।

स्पष्टीकरण:

d@                Run on each item X, return true if any aren't 0: 
  sY                  Ignore the numbers before this index
     ð_§XÃ            Get the indexes of numbers less than or equal to X
                          If it is a BST, this list will be e.g. [0,1,2...]
            -Y        Subtract the position within the index list from each index
                          eg. [0,1,2] -> [0,0,0] , [0,1,4] -> [0,0,2]
          xÈ          Sum the resulting array

— कामिल दकरी
स्रोत

1

स्काला

सभी दृष्टिकोण tsh द्वारा दिखाए गए नियम के कार्यान्वयन हैं।

109

l.zipWithIndex.foldLeft(1>0){case(r,(v,i))=>r&l.zip(l.tail).slice(i+1,l.size).forall(x=>l(i)>x._1|l(i)<x._2)}

101

(for(i<-l.indices)yield l.zip(l.tail).slice(i+1,l.size).forall(x =>l(i)>x._1|l(i)<x._2)).forall(x=>x)

98

l.indices.foldLeft(1>0)((r,i)=>r&(l.zip(l.tail).slice(i+1,l.size).forall(x=>l(i)>x._1|l(i)<x._2)))

78

(for(i<-l.indices;j<-i+1 to l.size-2)yield l(i)>l(j)|l(i)<l(j+1)).forall(x=>x)

यदि यह एक फ़ंक्शन और न केवल एक अभिव्यक्ति होना चाहिए, तो प्रत्येक पंक्ति को (17 बाइट्स) के साथ शुरू करना होगा

def%(l:Seq[Int])=

— डॉ। वाई विट
स्रोत

0

Oracle SQL, 177 बाइट्स

with r(i,v)as(select rownum,value(t)from table(a)t)
select nvl(min(case when r.v<p.l and r.v>p.v then 0end),1)from r,(select i,lag(v)over(order by i)l,v from r)p where r.i+1<p.i

चूंकि Oracle SQL में कोई बूलियन प्रकार नहीं है, इसलिए क्वेरी 1 या 0 पर वापस आती है।

Oracle SQL 12c, 210 बाइट्स

with function f(n ku$_objnumset,i int)return int as begin return n(i);end;
select min(case when f(c,1)>f(c,2)or f(c,1)<f(c,3)then 1else 0end)from(select value(t)c from table(powermultiset_by_cardinality(a,3))t)

यह एसक्यूएल में उसी तरह पीएल / एसक्यूएल में एरे का एक्सेस एलीमेंट नहीं है - यानी (ए), इस प्रकार उस उद्देश्य के लिए फ़ंक्शन fघोषित किया गया था with clause। अन्यथा समाधान बहुत कम होता।

अन्य सीमाएँ

3 तत्वों से कम सरणियों के लिए एक अपवाद फेंकता है (बदले में 1)
ऐसी धारणा है कि powermultiset_by_cardinality आदेश को संरक्षित करता है, भले ही इसे दस्तावेज़ में स्पष्ट रूप से नहीं बताया गया हो

sqlplus लिस्टिंग

SQL> set heading off
SQL> with r(i,v)as(select rownum,value(t)from table(ku$_objnumset(6,3,2,4,5,1,8,7,9))t)
  2  select nvl(min(case when r.v<p.l and r.v>p.v then 0end),1)from r,
  3  (select i,lag(v)over(order by i)l,v from r)p where r.i+1<p.i
  4  /

                                            0

SQL> with function f(n ku$_objnumset,i int)return int as begin return n(i);end;
  2  select min(case when f(c,1)>f(c,2)or f(c,1)<f(c,3)then 1else 0end)
  3  from(select value(t)c from table(powermultiset_by_cardinality(ku$_objnumset(6,3,2,4,5,1,8,7,9),3))t)
  4  /

                                                     0

SQL> with r(i,v)as(select rownum,value(t)from table(ku$_objnumset(8,3,1,6,4,7,10,14,13))t)
  2  select nvl(min(case when r.v<p.l and r.v>p.v then 0end),1)from r,
  3  (select i,lag(v)over(order by i)l,v from r)p where r.i+1<p.i
  4  /

                                            1

SQL> with function f(n ku$_objnumset,i int)return int as begin return n(i);end;
  2  select min(case when f(c,1)>f(c,2)or f(c,1)<f(c,3)then 1else 0end)
  3  from(select value(t)c from table(powermultiset_by_cardinality(ku$_objnumset(8,3,1,6,4,7,10,14,13),3))t)
  4  /

                                                     1

ऑनलाइन सत्यापन apex.oracle.com

अद्यतन करें

Oracle SQL, 155 बाइट्स

with r(i,v)as(select rownum,value(t)from table(a)t)select nvl(min(case when a.v<b.v and a.v>c.v then 0end),1)r from r a,r b,r c where a.i<b.i and b.i+1=c.i

— डॉ। वाई विट
स्रोत

0

सी, 823 बाइट्स (व्हॉट्सएप वर्णों की गिनती नहीं); 923 बाइट्स (व्हॉट्सएप सहित)

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct tree
{struct tree * left;struct tree * right;int val;}tree;static int * test_p = 0;
void insert_root(tree ** root, int in)
{if (*root == NULL){*root = (tree *)calloc(1,sizeof(tree));(*root)->val = in;return;}else if (in < (*root)->val){insert_root(&((*root)->left),in);}else{insert_root(&((*root)->right),in);}}
void preorder(tree * root)
{if ( root == 0x0 ) { return; }*test_p++ = root->val;preorder(root->left);preorder(root->right);}
int main(int argc, char ** argv)
{int test_list[argc-1];memset(test_list,0,argc*sizeof(int));test_p = test_list;tree * root = (tree *)calloc(1,sizeof(tree));root->val = strtol(argv[1],0x0,10);int i = 1;while ( argv[++i] != 0x0 ){insert_root(&root,strtol(argv[i],0x0,10));}preorder(root);test_p = test_list;i = 1;while ( ( i < argc ) ){if ( *test_p != strtol(argv[i],0x0,10) ){return 0;}test_p++;i++;}return 1;}

कार्यक्रम का पठनीय संस्करण नीचे है:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct tree
{
    struct tree * left;

    struct tree * right;

    int val;

} tree;


static int * test_p = 0;

void insert_root(tree ** root, int in)
{
  if (*root == NULL)
  {
    *root = (tree *)calloc(1,sizeof(tree));

    (*root)->val = in;

    return;
  }

  else if (in < (*root)->val)
  {
    insert_root(&((*root)->left),in);
  }

  else
  {
    insert_root(&((*root)->right),in);
  }
}

void preorder(tree * root)
{
    if ( root == 0x0 ) {  return; }

        *test_p++ = root->val;

        preorder(root->left);

        preorder(root->right);

}

int main(int argc, char ** argv)
{
    int test_list[argc-1];

    memset(test_list,0,argc*sizeof(int));

    test_p = test_list;

    tree * root = (tree *)calloc(1,sizeof(tree));

    root->val = strtol(argv[1],0x0,10);

    int i = 1;

    while ( argv[++i] != 0x0 )
    {
        insert_root(&root,strtol(argv[i],0x0,10));
    }

    preorder(root);

    test_p = test_list;

    i = 1;

    while ( ( i < argc ) )
    {
        if ( *test_p != strtol(argv[i],0x0,10) )
        {
            return 0;
        }

        test_p++;

        i++;
    }

    return 1;   
}

इस कार्यक्रम में मुख्य विधि उन नंबरों की सूची को पढ़ती है जो (कथित रूप से) एक वैध प्रचलन ट्रैवर्सल हैं।

फ़ंक्शन Insert_root जिसे पूर्णांक बाइनरी खोज ट्री में सम्मिलित करता है, जहां पिछले नोड्स में कम मान होते हैं और अगले नोड में बड़े अंतर मान होते हैं।

फ़ंक्शन प्रीऑर्डर (रूट) ट्री को प्रीऑर्डर ट्रैवर्सल में ट्रावर्स करता है और साथ ही साथ प्रत्येक इंटीजर को एल्गोरिथ्म में समाहित करता है एल्गोरिथ्म इंट सरणी टेस्ट_लिस्ट में आता है ।

एक अंतिम जबकि पाश परीक्षण करता है, तो में पूर्णांक से प्रत्येक मान के stdin में सूची और उन test_list प्रत्येक सूचकांक में बराबर हैं। अगर वहाँ से एक सूची तत्व है stdin कि संबंधित सूचकांक में test_list में इसी तत्व से मिलान करने में विफल रहता है, मुख्य कार्य रिटर्न 0. वरना मुख्य विधि रिटर्न 1 ।

यह निर्धारित करने के लिए कि मुख्य क्या लौटा है, बैश टर्मिनल में $ प्रतिध्वनि लिखें । BASH 1 या 0 का प्रिंट आउट लेगा।

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

2

आपका स्कोर एक गिनती का व्हाट्सएप है।

— गेहूं जादूगर

क्या यह एक BST पूर्व-आदेश है?

पृष्ठभूमि

चुनौती

इनपुट

उत्पादन

नियम

उदाहरण

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

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

प्रमाण

प्री-ऑर्डर ट्रैवर्सल में कोई अयोग्य अनुवर्ती शामिल नहीं है

बाद के अयोग्य घोषित किए बिना अलग पूर्णांकों की एक सूची एक BST का पूर्व-क्रम अनुक्रमणिका है

जावा 10, 94 बाइट्स

रूबी , 46 40 38 बाइट्स

रेटिना 0.8.2 , 31 बाइट्स

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

व्याख्या

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

स्काला ( 68 67 बाइट्स)

स्काला ( 122 103 बाइट्स)

स्पष्टीकरण:

05AB1E , 15 10 बाइट्स

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

जाप , 14 बाइट्स

स्काला

109

101

98

78

Oracle SQL, 177 बाइट्स

Oracle SQL 12c, 210 बाइट्स

Oracle SQL, 155 बाइट्स

सी, 823 बाइट्स (व्हॉट्सएप वर्णों की गिनती नहीं); 923 बाइट्स (व्हॉट्सएप सहित)