14

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

आपकी चुनौती, क्या आपको इसे स्वीकार करने का विकल्प चुनना चाहिए, यह निर्धारित करने के लिए कि क्या सरणी एक वैध ढेर है। एक सरणी ढेर के रूप में है यदि प्रत्येक तत्व के बच्चे तत्व से स्वयं के बराबर या उससे छोटे हैं। एक उदाहरण के रूप में निम्नलिखित सरणी लें:

[90, 15, 10, 7, 12, 2]

वास्तव में, यह एक सरणी के रूप में व्यवस्थित बाइनरी ट्री है। ऐसा इसलिए है क्योंकि हर तत्व में बच्चे हैं। 90 के दो बच्चे हैं, 15 और 10।

       15, 10,
[(90),         7, 12, 2]

15 के बच्चे भी हैं, 7 और 12:

               7, 12,
[90, (15), 10,        2]

10 के बच्चे हैं:

                      2
[90, 15, (10), 7, 12,  ]

और अगला तत्व भी 10 का बच्चा होगा, सिवाय इसके कि कोई जगह नहीं है। 7, 12 और 2 के सभी बच्चे भी होंगे अगर सरणी काफी लंबी थी। यहाँ एक ढेर का एक और उदाहरण दिया गया है:

[16, 14, 10, 8, 7, 9, 3, 2, 4, 1]

और यहाँ उस पेड़ का एक दृश्य है जिसे पिछला सरणी बनाता है:

बस अगर यह पर्याप्त रूप से स्पष्ट नहीं है, तो यहां i'th तत्व के बच्चों को प्राप्त करने के लिए स्पष्ट सूत्र है

//0-indexing:
child1 = (i * 2) + 1
child2 = (i * 2) + 2

//1-indexing:
child1 = (i * 2)
child2 = (i * 2) + 1

आपको इनपुट के रूप में एक गैर-खाली सरणी लेनी चाहिए और यदि सरणी क्रम में है, और एक मिथ्या मूल्य अन्यथा, तो सत्य मूल्य का उत्पादन करें। यह एक 0-अनुक्रमित हीप, या 1-अनुक्रमित हीप हो सकता है जब तक आप निर्दिष्ट करते हैं कि आपके प्रोग्राम / फ़ंक्शन की कौन सी प्रारूप की अपेक्षा है। आप मान सकते हैं कि सभी सरणियों में केवल सकारात्मक पूर्णांक होंगे। आप किसी भी ढेर-बिल्डरों का उपयोग नहीं कर सकते हैं । इसमें शामिल है, लेकिन यह सीमित नहीं है

कार्य जो यह निर्धारित करते हैं कि कोई सरणी ढेर-रूप में है
ऐसे कार्य जो किसी सरणी को ढेर या ढेर-रूप में परिवर्तित करते हैं
ऐसे कार्य जो इनपुट के रूप में एक सरणी लेते हैं और एक ढेर डेटा-संरचना लौटाते हैं

यदि कोई सरणी ढेर-रूप में है या नहीं (0 अनुक्रमित) सत्यापित करने के लिए आप इस अजगर स्क्रिप्ट का उपयोग कर सकते हैं:

def is_heap(l):
    for head in range(0, len(l)):
        c1, c2 = head * 2 + 1, head * 2 + 2
        if c1 < len(l) and l[head] < l[c1]:
            return False
        if c2 < len(l) and l[head] < l[c2]:
            return False

    return True

टेस्ट IO:

इन सभी निविष्टियों को वापस लौटना चाहिए:

[90, 15, 10, 7, 12, 2]
[93, 15, 87, 7, 15, 5]
[16, 14, 10, 8, 7, 9, 3, 2, 4, 1]
[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
[100, 19, 36, 17, 3, 25, 1, 2, 7]
[5, 5, 5, 5, 5, 5, 5, 5]

और इन सभी इनपुट्स को गलत लौटना चाहिए:

[4, 5, 5, 5, 5, 5, 5, 5]
[90, 15, 10, 7, 12, 11]
[1, 2, 3, 4, 5]
[4, 8, 15, 16, 23, 42]
[2, 1, 3]

हमेशा की तरह, यह कोड-गोल्फ है, इसलिए मानक कमियां लागू होती हैं और बाइट्स में सबसे कम जवाब जीतता है!

— जेम्स
स्रोत

जेली, 1 1 9 5 बाइट्स

x2:ḊṂ

4 बाइट्स हटाकर डेनिस को धन्यवाद!

इसे यहाँ आज़माएँ।

व्याख्या

x2          Duplicate each element.
:Ḋ          Each element divided by the input with the first element removed,
            as integer, so there is a 0 only if some element in the duplicated
            list is less than the corresponding element in the other.
            There are also elements left unchanged, but it doesn't matter as
            the input is all positive.
Ṃ           Minimum in the list.

— jimmy23013
स्रोत

10

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

a=>!a.some((e,i)=>e>a[i-1>>1])

संपादित करें: विशिष्ट स्पष्टीकरण लागत 1 बाइट के लिए मेरे कोड को ठीक करना, इसलिए 4 बाइट बचाने के लिए @ edc65 के लिए धन्यवाद।

— नील
स्रोत

यह 2 [93, 15, 87, 7, 15, 5]और 6[5, 5, 5, 5, 5, 5, 5, 5]

— edc65

यह बेहतर काम करता है और a=>!a.some((e,i)=>e>a[i-1>>1])

— बजे

1

@ edc65 मेरे उत्तर लिखने के बाद वे टेस्टकेस जोड़े गए।

— नील

5

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

f(a:b)=and$zipWith(<=)b$a:b<*"xx"

या

and.(zipWith(<=).tail<*>(<*"xx"))

— एंडर्स कसीर्ग
स्रोत

4

जे, 24 बाइट्स

*/@:<:]{~0}:@,<.@-:@i.@#

व्याख्या

*/@:<:]{~0}:@,<.@-:@i.@#  Input: s
                       #  Count of s
                    i.@   Create range [0, 1, ..., len(s)-1]
                 -:@      Halve each
              <.@         Floor each
         0   ,            Prepend a zero to it
          }:@             Remove the last value to get the parent indices of each
      ]                   Identity function to get s
       {~                 Take the values from s at the parent indices
    <:                    For each, 1 if it is less than or equal to its parent else 0
*/@:                      Reduce using multiplication and return

— मील की दूरी पर
स्रोत

3

MATL , 13 12 बाइट्स

ttf2/k)>~4L)

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

एक सरणी सत्य है यदि यह गैर-रिक्त है और इसकी सभी प्रविष्टियाँ गैर-शून्य हैं। अन्यथा यह मिथ्या है। यहाँ कुछ उदाहरण हैं ।

व्याख्या

t     % Take input implicitly. Duplicate
tf    % Duplicate and push indices of nonzero entries. This gives [1 2 ... n] where n
      % is input size
2/k   % Divide by 2 and round down
)     % Index into input. Gives array of parents, except for the first entry
>~    % True for entries of the input that don't exceed those in the array of parents
4L)   % Discard first entry

— लुइस मेंडो
स्रोत

2

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

f=lambda l:l==[]or l[len(l)/2-1]/l.pop()*f(l)

फैल्सी के लिए आउटपुट 0, ट्रू के लिए नॉनज़रो।

जाँचता है कि अंतिम तत्व सूचकांक में अपने माता-पिता से कम या बराबर है len(l)/2-1। फिर, यह जाँचने के लिए पुन: बताता है कि हटाए गए सूची के अंतिम तत्व के साथ भी यही सत्य है, और जब तक सूची खाली न हो।

48 बाइट्स:

f=lambda l,i=1:l==l[:i]or l[~-i/2]/l[i]*f(l,i+1)

जाँचता है कि प्रत्येक सूचकांक में i, तत्व सूचकांक में अपने मूल माता-पिता पर है (i-1)/2। यदि यह मामला नहीं है, तो फ़्लोर-डिवीज़न 0 का उत्पादन करता है।

बेस केस को i/len(l)orकरने से लंबाई समान होती है। मैंने पहली बार ज़िपिंग की कोशिश की थी, लेकिन लंबे समय तक कोड (57 बाइट्स) मिला।

lambda l:all(map(lambda a,b,c:b<=a>=c,l,l[1::2],l[2::2]))

— XNOR
स्रोत

1

आर, 97 88 82 बाइट्स

उम्मीद है कि मैंने इसे सही ढंग से समझा है। अब देखना है कि क्या मैं कुछ और बाइट्स से छुटकारा पा सकता हूं। Rbind को डुबोया और एक नीलम में लगाया और 1-आधारित वेक्टर के साथ ठीक से व्यवहार किया।

एक अनाम फ़ंक्शन के रूप में कार्यान्वित किया गया

function(Y)all(sapply(1:length(Y),function(X)Y[X]>=Y[X*2]&Y[X]>=Y[X*2+1]),na.rm=T)

परीक्षण के कुछ मामलों के साथ

> f=
+ function(Y)all(sapply(1:length(Y),function(X)Y[X]>=Y[X*2]&Y[X]>=Y[X*2+1]),na.rm=T)
> f(c(90, 15, 10, 7, 12, 2))
[1] TRUE
> f(c(93, 15, 87, 7, 15, 5))
[1] TRUE
> f(c(10, 9, 8, 7, 6, 5, 4, 3, 2, 1))
[1] TRUE
> f(c(5, 5, 5, 5, 5, 5, 5, 5))
[1] TRUE
> f(c(4, 5, 5, 5, 5, 5, 5, 5))
[1] FALSE
> f(c(90, 15, 10, 7, 12, 11))
[1] FALSE
> f(c(4, 8, 15, 16, 23, 42))
[1] FALSE

— MickyT
स्रोत

आप उपयोग कर सकते हैं seq(Y)के बजाय 1:length(Y)।

— rturnbull

1

CJam, 19 16 13 12 बाइट्स

q~_:_\(;./:*

डेनिस की बदौलत 3 बाइट से गॉकेटेड।

इसे यहाँ आज़माएँ।

— jimmy23013
स्रोत

1

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

.AgV.i+h

       hQ      first element of input
      +  Q     plus input
    .i    Q    interleaved with input
  gV       Q   vectorized greater-than-or-equal comparison with input
.A             check if all results are true

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

— एंडर्स कसीर्ग
स्रोत

1

रेटिना , 51 बाइट्स

\d+
$*
^(?!(1+ )*(1+) 1* ?(?<-1>1+ )*(?(1)(?!))1\2)

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

इनपुट के रूप में संख्याओं की एक अलग-अलग सूची लेता है। सत्य / असत्य के लिए आउटपुट 1/0

— TwiNight
स्रोत

0

सी ++ 14, 134 105 बाइट्स

#define M(d) (2*i+d<c.size()&&(c[i]<c[2*i+d]||f(c,2*i+d)==0))
int f(auto&c,int i=0){return!(M(1)||M(2));}

cएक कंटेनर का समर्थन करने की आवश्यकता है .operator[](int)और .size(), जैसे std::vector<int>।

Ungolfed:

int f(auto& c, int i=0) {
    if (2*i+1<c.size() && c[i] < c[2*i+1]) return 0;
    if (2*i+2<c.size() && c[i] < c[2*i+2]) return 0;
    if (2*i+1<c.size() && (f(c,2*i+1) == 0)) return 0;
    if (2*i+2<c.size() && (f(c,2*i+2) == 0)) return 0;
    return 1;
}

छोटा हो सकता है अगर सत्य = 0और मिथ्या = 1अनुमति दी जाएगी।

— कार्ल नेफ
स्रोत

0

आर, 72 बाइट्स

अन्य आर उत्तर से थोड़ा अलग दृष्टिकोण ।

x=scan();all(diff(x[c(a<-1:(N<-sum(1|x)),a,a*2,a*2+1)],l=N*2)<1,na.rm=T)

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

व्याख्या

स्टड से इनपुट पढ़ें:

x=scan();

हमारे जोड़े बनाएँ। हम मूल नोड्स के लिए 1...N(जहां Nलंबाई है x) के सूचकांक बनाते हैं। हम इसे दो बार लेते हैं क्योंकि प्रत्येक माता-पिता के पास (अधिकतम) दो बच्चे हैं। हम बच्चों को भी लेते हैं, (1...N)*2और (1...N)*2+1। की लंबाई से परे सूचकांकों के लिए x, आर रिटर्न NA, 'उपलब्ध नहीं'। इनपुट के लिए 90 15 10 7 12 2, यह कोड हमें देता है 90 15 10 7 12 2 90 15 10 7 12 2 15 7 2 NA NA NA 10 12 NA NA NA NA।

                  x[c(a<-1:(N<-sum(1|x)),a,a*2,a*2+1)]

जोड़े के इस सदिश में, प्रत्येक तत्व का N*2दूर की दूरी पर उसका साथी है। उदाहरण के लिए, आइटम 1 का भागीदार 12 (6 * 2) की स्थिति पर स्थित है। हम diffइन जोड़े के बीच अंतर की गणना करने के लिए उपयोग करते lag=N*2हैं, आइटम को उनके सही भागीदारों की तुलना करने के लिए निर्दिष्ट करते हैं। NAतत्वों पर कोई भी कार्रवाई बस वापस आती है NA।

             diff(x[c(a<-1:(N<-sum(1|x)),a,a*2,a*2+1)],l=N*2)

अंत में, हम जांचते हैं कि इन सभी लौटे मानों की तुलना में कम है 1(यानी कि पहली संख्या, माता-पिता, दूसरे नंबर, बच्चे से बड़ी थी), NAविचार से मूल्यों को छोड़कर ।

         all(diff(x[c(a<-1:(N<-sum(1|x)),a,a*2,a*2+1)],l=N*2)<1,na.rm=T)

— rturnbull
स्रोत

0

दरअसल , 16 बाइट्स

यह उत्तर काफी हद तक jimmy23013 के जेली उत्तर पर आधारित है । गोल्फ सुझाव का स्वागत करते हैं! इसे ऑनलाइन आज़माएं!

;;2╟┬Σ1(tZ`i<`Mm

Ungolfing

         Implicit input a.
;;       Duplicate a twice.
2╟       Wrap two of the duplicates into a list.
┬        Transpose the duplicates.
Σ        Sum all of the columns to get a flat list like this:
           [a_0, a_0, a_1, a_1, ..., a_n, a_n]
         This gets the parent nodes of the heap.
1(t      Get a[1:] using the remaining duplicate of a.
         This is a list of the child nodes of the heap.
Z`i<`M   Check if every child node is less than its parent node.
m        Get the minimum. This returns 1 if a is a max-heap, else 0.
         Implicit return.

— Sherlock9
स्रोत

यह एक अधिकतम ढेर है?

टेस्ट IO:

जेली, 1 1 9 5 बाइट्स

व्याख्या

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

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

जे, 24 बाइट्स

व्याख्या

MATL , 13 12 बाइट्स

व्याख्या

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

आर, 97 88 82 बाइट्स

CJam, 19 16 13 12 बाइट्स

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

रेटिना , 51 बाइट्स

सी ++ 14, 134 105 बाइट्स

आर, 72 बाइट्स

व्याख्या

दरअसल , 16 बाइट्स