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]

পূর্ববর্তী অ্যারে যে গাছটি তৈরি করেছে তা এখানে দৃশ্যমান:

কেবলমাত্র যদি এটি যথেষ্ট পরিমাণে পরিষ্কার না হয় তবে এখানে উপাদানটির বাচ্চাদের পাওয়ার সুস্পষ্ট সূত্র

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

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

আপনাকে অবশ্যই ইনপুট হিসাবে একটি শূন্য খালি অ্যারে নিতে হবে এবং অ্যারেটি হ্যাপ ক্রমে থাকলে এবং একটি মিথ্যা মানটি আউটপুট করতে হবে otherwise এটি 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

পরীক্ষার আইও:

এই সমস্ত ইনপুট সত্য হওয়া উচিত:

[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]

যথারীতি, এটি কোড-গল্ফ, সুতরাং স্ট্যান্ডার্ড লুফোলস প্রয়োগ হয় এবং বাইটের মধ্যে সবচেয়ে কম উত্তর!

— জেমস
সূত্র

সম্পর্কিত

— জেমস

এটি কি সঠিক যে যদি বারবার উপাদান থাকে তবে এই সংজ্ঞা অনুসারে গাদা গঠন করা অসম্ভব হতে পারে?

— '23 এ 23

@ ফেয়ারসাম কি হবে [3, 2, 1, 1]?

— নিল

@ ফেয়ারসাম এটি একটি দুর্দান্ত বিষয়, আমি এটি ভাবিনি। আমি একটি স্তূপের বর্ণনা আপডেট করেছি এবং সদৃশ উপাদানগুলির সাথে কিছু উদাহরণ যুক্ত করেছি। ধন্যবাদ!

— জেমস

5

একটি গাদা অগ্রাধিকার সারি হিসাবে পরিচিত হয় না। একটি অগ্রাধিকারের সারিটি বিমূর্ত ডেটা টাইপ। একটি হিপ এমন ডেটা স্ট্রাকচার যা মাঝে মাঝে অগ্রাধিকারের সারিটি প্রয়োগ করতে ব্যবহৃত হয় (আরও বেশি তহবিলের ডেটা স্ট্রাকচারের উপরে গাদা নিজেই প্রয়োগ করা হয়, তবে এটি বিন্দুর পাশে) is সংযুক্ত তালিকার মতো - অন্যান্য ডেটা স্ট্রাকচারের শীর্ষে অগ্রাধিকারের সারিগুলি প্রয়োগ করা যেতে পারে।

— লিন্ডন হোয়াইট

7

জেলি, 11 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

জাভাস্ক্রিপ্ট (ES6), 34 30 বাইট

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

সম্পাদনা: নির্দিষ্ট স্পষ্টকরণের জন্য আমার কোডটি 1 বাইটের জন্য ঠিক করা, সুতরাং 4 বাইট সংরক্ষণ করার জন্য @ এডসি 65 কে ধন্যবাদ।

— নিল
সূত্র

এটি [93, 15, 87, 7, 15, 5][5, 5, 5, 5, 5, 5, 5, 5]

— টেস্টকেস

এটি আরও ভাল কাজ করে এবং 3 চর খাটোa=>!a.some((e,i)=>e>a[i-1>>1])

— edc65

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

এমএটিএল , 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 বাইট

আশা করি আমি এটি সঠিকভাবে বুঝতে পেরেছি। এখন আরও কিছু বাইট থেকে মুক্তি পেতে পারি কিনা তা দেখার জন্য। আরবাইন্ডটি খনন করে একটি নীলচে রাখুন এবং 1-ভিত্তিক ভেক্টরকে সঠিকভাবে ডিল করুন।

নামহীন ফাংশন হিসাবে প্রয়োগ করা হয়েছে

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

কয়েকটি পরীক্ষার মামলা নিয়ে With

> 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 বাইট

এই উত্তরটি মূলত জিমি 23013 এর জেলি উত্তরের উপর ভিত্তি করে । গল্ফিং পরামর্শ স্বাগত! এটি অনলাইন চেষ্টা করুন!

;;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
সূত্র

এটি কি সর্বোচ্চ গাদা?

পরীক্ষার আইও:

জেলি, 11 9 5 বাইট

ব্যাখ্যা

জাভাস্ক্রিপ্ট (ES6), 34 30 বাইট

হাস্কেল, 33 বাইট

জে, 24 বাইট

ব্যাখ্যা

এমএটিএল , 13 12 বাইট

ব্যাখ্যা

পাইথন 2, 45 বাইট

আর, 97 88 82 বাইট

CJam, 19 16 13 12 বাইট

পাইথ, 8 বাইট

অক্ষিপট , 51 বাইট

সি ++ 14, 134 105 বাইট

আর, 72 বাইট

ব্যাখ্যা

প্রকৃতপক্ষে , 16 বাইট