স্ট্যাকেবল ক্রম


29

আপনি একবার ডেক থেকে 0 থেকে 9 লেবেল কার্ডগুলি একবার ব্যবহার করেন, 0 থেকে শুরু করে স্ট্যাক তৈরি করেন এবং 1 দ্বারা গণনা করুন।

  • আপনি যখন একটি 0 লেনদেন করেন, আপনি নতুন স্ট্যাক শুরু করার জন্য এটি টেবিলের উপরে রাখবেন।
  • আপনি যখন অন্য কোনও কার্ড লেনদেন করেন, আপনি একে একে একে একে একে একে একে একে একে একে একে একে একে একে একে একে একে কম বেশি কমিয়ে দেওয়ার মতো। যদি এই জাতীয় কোনও কার্ড না থাকে তবে ডেকটি স্ট্যাকযোগ্য নয়।

একটি ডেক দেওয়া, প্রদত্ত ক্রমে ডিল করার সময় এটি স্ট্যাক করা যায় কিনা তা নির্ধারণ করুন। সমানভাবে, অঙ্কগুলির একটি তালিকা দেওয়া হলে, সিদ্ধান্ত নিন যে এটি ফর্মের প্রতিটিকে পৃথক পৃথক বিভাগে ভাগ করা যায় কিনা?0,1,..,k

উদাহরণ

ডেক নিন 0012312425। প্রথম দুটি কার্ড হ'ল 0, তাই তারা টেবিলে যায়:

Stacks: 00

  Deck: 12312425

এর পরে, আমরা একটি ডিল করি 1, যা একটিতে চলে যায় 0, তাতে কোন ব্যাপার নেই:

        1
Stacks: 00

  Deck: 2312425

তারপরে আমরা 2সবেমাত্র স্থাপন করা একটি শীর্ষে 1এবং 3এটির উপরে deal

        3
        2
        1
Stacks: 00

  Deck: 12425

এর পরে 1, 2এবং প্রথম স্ট্যাকের 4শীর্ষে এবং দ্বিতীয়টির উপরে op

        4
        3
        22
        11
Stacks: 00

  Deck: 25

এখন, আমাদের একটি স্থাপন করা দরকার 2, তবে 1উভয়ই স্ট্যাক নেই। সুতরাং, এই ডেক স্ট্যাকযোগ্য ছিল না।

ইনপুট: 0-9 সংখ্যাগুলির একটি অদম্য তালিকা বা সেগুলির একটি স্ট্রিং। আপনি ধরে নিতে পারবেন না যে 0 সর্বদা ইনপুটটিতে থাকবে।

আউটপুট : দুটি স্বতন্ত্র সামঞ্জস্যপূর্ণ মানগুলির মধ্যে একটি, স্ট্যাকেবল সিকোয়েন্সগুলির জন্য একটি এবং নন-স্ট্যাকেবল মানগুলির জন্য

পরীক্ষার কেস:

পারে.তবে:

0
01
01234
00011122234567890
012031
0120304511627328390

স্ট্যাকেবল নয়:

1
021
0001111
0012312425
012301210
000112223

সুবিধার জন্য, তালিকা হিসাবে:

[0]
[0, 1]
[0, 1, 2, 3, 4]
[0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 4, 5, 6, 7, 8, 9, 0]
[0, 1, 2, 0, 3, 1]
[0, 1, 2, 0, 3, 0, 4, 5, 1, 1, 6, 2, 7, 3, 2, 8, 3, 9, 0]

[1]
[0, 2, 1]
[0, 0, 0, 1, 1, 1, 1]
[0, 0, 1, 2, 3, 1, 2, 4, 2, 5]
[0, 1, 2, 3, 0, 1, 2, 1, 0]
[0, 0, 0, 1, 1, 2, 2, 2, 3]

গোষ্ঠীবদ্ধ:

[[0], [0, 1], [0, 1, 2, 3, 4], [0, 0, 0, 1, 1, 1, 2, 2, 2, 3], [0, 1, 2, 0, 3, 1], [0, 1, 2, 0, 3, 0, 4, 5, 1, 1, 6, 2, 7, 3, 2, 8, 3, 9, 0]]
[[1], [0, 2, 1], [0, 0, 0, 1, 1, 1, 1], [0, 0, 1, 2, 3, 1, 2, 4, 2, 5]]

লিডারবোর্ড:


আমরা কি তালিকা দৈর্ঘ্যের একটি সীমা ধরে নিতে পারি?
orlp

@orlp এর স্পষ্ট সীমা নেই।
xnor

@ এক্সনর তিনি সম্ভবত int a[99]সি
লিকি নুন

@ লুইস মেন্ডো আপনি হয়ত বলতে পারেন, "অমানবিক"।
xnor

@ এক্সনর আহ, দুঃখিত, আমি এটি দেখিনি। অ্যারেটি কি 1-ভিত্তিক হতে পারে? অর্থাৎ নম্বর থেকে 1করতে10
লুইস Mendo

উত্তর:



6

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

একটি বেনাম ফাংশন পূর্ণসংখ্যার একটি তালিকা নিচ্ছে এবং ফিরে আসবে Bool

ব্যবহার: (all(<1).foldr(?)[]) [0,1,2,3,4]

all(<1).foldr(?)[]
m?l|(p,r)<-span(/=m+1)l=m:p++drop 1r

এটি অনলাইন চেষ্টা করুন!

কিভাবে এটা কাজ করে

  • foldr(?)[]?খালি তালিকা দিয়ে শুরু করে ডান থেকে বাম ব্যবহার করে তার তালিকার যুক্তিটি ভাঁজ করে । ফলাফলটি তালিকার নম্বরগুলির তালিকা যা পূর্ববর্তী সংখ্যার শীর্ষে ফিট করে না।
  • all(<1) যদি পূর্ববর্তী সংখ্যার উপরে একমাত্র সংখ্যাগুলি উপযুক্ত না হয় তবে এটি শূন্য হয় tests
  • m?lফিটনেসবিহীন সংখ্যার mতালিকায় একটি সংখ্যা প্রেরণ করে l। যদি m+1ইতিমধ্যে তালিকায় থাকে তবে এটি এখন শীর্ষে ফিট থাকায় এটি সরানো যাবে m
    • (p,r)<-span(/=m+1)lতালিকাটি lদুটি ভাগে বিভক্ত করে pএবং rসংখ্যার প্রথম বারে m+1। যদি কিছু না থাকে তবে ডান দিকটি rখালি থাকবে।
    • m:p++drop 1rprepends mবিভক্ত অংশে। যদি rঅমানবিক না হয়, তবে এটি অবশ্যই শুরু করা উচিত m+1, যা দ্বারা মুছে ফেলা হবে drop 1

বিপরীতে স্ট্যাকিং করছেন দুর্দান্ত ধারণা! আমি আপনার ?পুনরাবৃত্তভাবে প্রসারিত করার চেষ্টা করেছি , কিন্তু একই দৈর্ঘ্য পেয়েছি
xnor


5

কাস্তে , 9 বাইট

Λ¬ḞS:o-→ø

এটি অনলাইন চেষ্টা করুন!

1স্ট্যাকেবল ডেকে এবং স্ট্যাকএবল ডেকের জন্য ফিরে আসে 0

দেখে মনে হচ্ছে এরজান জোহানসেন তাঁর হাস্কেলের জবাবটিতে ইতিমধ্যে একই অ্যালগোরিদম নিয়ে এসেছেন, তবে হুস্কে এটি স্পষ্টতই আরও সংক্ষিপ্ত।

ব্যাখ্যা

আমরা সমস্যাটিকে অন্য দিক থেকে সরিয়ে দেব: ডেকটি ফ্লিপ করুন এবং অবতরণ পাইলস তৈরি করুন। সমস্ত ডেকের মধ্য দিয়ে যাওয়ার পরে যদি সমস্ত পাইলের শীর্ষে 0 থাকে তবে ডেকটি স্ট্যাকেবল হয়।

Λ¬ḞS:(-→)ø
         ø    Starting with the empty list (each element of this list will be the top card
              of a stack)
  ḞS          Traverse the input from right to left. For each card:
      -→        Remove the successor of this card from our list (if present)
    :           Add this card to our list
Λ¬            At the end, check if all the cards in our list are zeroes (falsy)

4

ওহ খুব সুন্দর. ‘Ṭ€+\I>0FṀসবসময় কাজ করবে ?
জোনাথন অ্যালান

@ জোনাথান অ্যালান ওয়েল, 2 নিয়মিত মূল্যবোধের নিয়ম থাকা উচিত।
এরিক দি আউটগল্ফার

4

সি (জিসিসি), 74 73 বাইট

f(int*l){int s[10]={},r=1;for(;~*l;s[*l++]++)r*=!*l||s[*l-1]--;return r;}

-1 দিয়ে শেষটি চিহ্নিত করতে ইনপুট অ্যারের প্রয়োজন। ব্যবহারের উদাহরণ:

int main(int argc, char** argv) {
    int a[] = {0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 4, 5, 6, 7, 8, 9, 0, -1};
    printf("%d\n",  f(a));
    return 0;
}

সাদামাটাতে কী দোষ return r?
ফাঁস নুন

4

রেটিনা , 42 বাইট

O$#`(.)(?<=(\1.*?)*)
$#2
.
$*1,
^(,|1\1)+$

এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা

O$#`(.)(?<=(\1.*?)*)
$#2

এটি অংকগুলি বাছাই করে, স্থিরভাবে, আগে একই অঙ্কটি কতবার ঘটেছিল by বাস্তবে, এটি এক সাথে বিভিন্ন প্রার্থীর উপসংস্থানগুলি সহযোগিতা করে। ফলস্বরূপ স্ট্রিংটিতে প্রথমে প্রতিটি অঙ্কের প্রথম উপস্থিতি এবং তারপরে প্রতিটি অঙ্কের দ্বিতীয় উপস্থিতি ইত্যাদি থাকবে। স্ট্যাকেবল ইনপুটে, ফলাফলটি দেখতে কিছুটা এমন দেখাবে 0123...0123...0123..., যেখানে এই প্রতিটি সাবস্ট্রিং যে কোনও বিন্দুতে শেষ হতে পারে।

ইনপুটটিতে অ্যানারিতে এই ধরণের প্যাটার্ন রয়েছে কিনা তা নির্ধারণ করা সবচেয়ে সহজ।

.
$*1,

আমরা প্রতিটি অঙ্ক n কে n 1 গুলি দ্বারা প্রতিস্থাপন করি এবং স্বতন্ত্র অঙ্কগুলি পৃথক করার জন্য কমা অনুসরণ করি।

^(,|1\1)+$

অবশেষে আমরা অঙ্কের ক্রমবর্ধমান রানের সাথে মেলে ফরোয়ার্ড রেফারেন্সটি ব্যবহার করি। আমরা পুরো স্ট্রিংটি একক কমা দিয়ে ( 0 টি উপস্থাপন করে যা একটি নতুন রান শুরু হয়) মেলানোর চেষ্টা করে বা অতিরিক্তের আগের আগের জিনিসটির সাথে মিল রেখে 1, যা কেবলমাত্র বর্তমান সংখ্যাটি পূর্ববর্তীটির উত্তরসূরি হলে তা কার্যকর হয়।


3

টিআই-বেসিক (৮ series টি সিরিজ), 25 বাইট (49 টি অক্ষর)

:min(seq(min(cumSum(Ans=I)≤cumSum(Ans=I-1)),I,1,9

কিভাবে এটা কাজ করে

তালিকা হিসাবে ইনপুট নেয় Ans। আউটপুট 1পারে.তবে ইনপুট জন্য, 0অন্যথায়।

প্রত্যেকের জন্য I, প্রতিটি প্রাথমিক বিভাগে cumSum(Ans=I)কতবার সংখ্যার তালিকার গণনা করা হয়েছে Iতা গণনা করা হয় min(cumSum(Ans=I)≤cumSum(Ans=I-1)), তবে প্রতি পজিশনে আমরা I-1কমপক্ষে বহুবার দেখেছি মাত্র 1 হয় I। সামগ্রিক প্রকাশটি 1যখনই এটি প্রতিটিটির জন্য ধারণ করে I


3

জাভাস্ক্রিপ্ট (ES6), 61 45 40 বাইট

তালিকা হিসাবে ইনপুট নেয়।

a=>a.every(k=>a[~k]=!k|a[-k]--&&-~a[~k])

পরীক্ষার মামলা

কিভাবে?

প্রতিটি মান 0 ... 9 এর জন্য আমরা পূর্ববর্তী কার্ডের উপরে থাকা স্ট্যাকের সংখ্যার উপর নজর রাখি। এই কাউন্টারগুলি একটি [-9] থেকে একটি [0] এ সংরক্ষণ করা হয় , যেখানে একটি [] আসল ইনপুট অ্যারে। ইনপুট ডেটাগুলির সাথে সংঘর্ষের একমাত্র কাউন্টারটি হ'ল [0] , তবে আমরা সত্যিই এটির বিষয়ে চিন্তা করি না কারণ 1) 0 লেবেলযুক্ত কার্ডগুলি সর্বদা অনুমোদিত এবং যে কোনও উপায়ে আলাদাভাবে প্রক্রিয়া করতে হবে এবং 2) ইনপুট মানটি একটি [0 ] এটি আপডেট করার সুযোগ পাওয়ার আগে প্রক্রিয়াজাত করা হয়।

a => a.every(k =>  // given the input array a, for each card k in a:
  a[~k] =          // the card is valid if:
    !k |           //   - it's a 0 or
    a[-k]-- &&     //   - there's at least one stack with the card k-1 atop
    -~a[~k]        // in which case we allow a new card k+1 and go on with the next card
)                  // otherwise, every() fails immediately

আপনি আমার চেয়ে দ্রুত: o
লিকি নুন

@LakakyNun আপনি অবশ্যই 20 মিনিটের জন্য দূরে থাকতেন ...;)
আর্নাউল্ড

2

এমএটিএল , 16 বাইট

0*GQ"@yQy=f1)(]a

ইনপুট হল সংখ্যার একটি অ্যারে।

কোডটি 1ইনপুট স্ট্যাকযোগ্য হলে STDOUT এ আউটপুট দেয় বা এসিপিডিআউটে একটি ত্রুটি এবং খালি আউটপুট সহ প্রস্থান করে যদি ইনপুট স্ট্যাকযোগ্য না হয়।

এটি অনলাইন চেষ্টা করুন!





2

আর , 88 বাইট

function(d){s={}
for(e in d)if(!e)s=c(s,0)else{k=match(e,s+1)
if(is.na(k))T=F
s[k]=e}
T}

এটি অনলাইন চেষ্টা করুন!

ফাংশন যা একটি আর ভেক্টর নেয়; TRUEস্ট্যাকেবল এবং FALSEঅস্থির জন্য ফিরে আসে ।

ব্যাখ্যা:

function(d){
 s <- {}              # initialize the stacks as empty
 for(e in d){         # iterate over the deck
  if(!e)              # if e is zero
   s <- c(s,0)        # start a new stack
  else {              # otherwise
   k <- match(e,s+1)  # find where e should go in s, NA if not there
   if(is.na(k))       # if no match (unstackable)
    T <- F            # set T to F (False)
   s[k] <- e          # set s[k] to e
  }
 T                    # return the value of T, which is TRUE by default and only gets changed in the loop to F.
}

2

নিম, 133 বাইট

proc s(d:seq[int]):int=
 var
  t= @[0]
  r=1
 for c in d:(t.add(0);var f=0;for i,s in t.pairs:(if s==c:(t[i]=c+1;f=1;break));r*=f)
 r

1যদি এটা কাজ করে; 0যদি এটি না হয়।

ওহ ভাল, for- লুপগুলিতে পরিবর্তনশীলগুলির পরিবর্তনশীলতা মোকাবেলা করার জন্য কিছু মজার ব্যবসা করতে হয়েছিল।


1

হাস্কেল , 77 75 বাইট

import Data.List
g[]=1<3
g(x:r)|s<-r\\[x-1]=g r&&(x<1||s/=r&&g s)
g.reverse

এটি অনলাইন চেষ্টা করুন! ব্যবহার: g.reverse $ [0,1,2]Trueস্ট্যাকেবল ইনপুট এবং Falseঅন্যথায় ফেরত দেয় ।

এটি একটি পুনরাবৃত্ত সমাধান যা কোনও প্রদত্ত তালিকার পিছন থেকে সামনের দিকে পিছনে যায়। এটি পর্যবেক্ষণ কার্যকর করে যে

  • খালি তালিকাটি স্ট্যাকেবল।
  • উপসর্গ rএবং শেষ উপাদান সহ একটি খালি খালি তালিকা xস্ট্যাকযোগ্য যদি rহয় xশূন্য হয় বা হয় উভয় x-1উপস্থিত হয় rএবং সরানো rসহ x-1এছাড়াও স্ট্যাকযোগ্য।

1

জাভা 8, 168 150 142 বাইট

a->{int x[]=new int[a.length],s=0,i;a:for(int n:a){if(n<1){s++;continue;}for(i=0;i<s;i++)if(x[i]==n-1){x[i]=n;continue a;}return 0;}return 1;}

রিটার্নস 0/1 এটি সঠিকভাবে সজ্জিত কিনা।

ব্যাখ্যা:

এখানে চেষ্টা করুন।

a->{                         // Method with integer-array parameter and integer return-type
  int x[]=new int[a.length], //  Array for the stacks, (max) size equal to input-size
      s=0,                   //  Amount of stacks, starting at 0
      i;                     //  Index integer
  a:for(int n:a){            //  Loop (1) over the input
    if(n<1){                 //   If the current item is a zero:
      s++;                   //    Increase amount of stacks `s` by 1
      continue;}             //    And go to the next iteration
    for(i=0;i<s;i++)         //   Inner loop (2) over the stacks
      if(x[i]==n-1){         //    If a top item of a stack equals the current item - 1:
        x[i]=n;              //     Set this item in the stacks-array
        continue a;}         //     And go to the next iteration of loop (1)
    return 0;                //   If we haven't encountered a `continue`, return 0
  }                          //  End of loop (1)
  return 1;                  //  Return 1 if we were able to correctly stack everything
}                            // End of method

1

সি, 248 বাইট

দ্রষ্টব্য: রিটার্নের স্থিতি মুদ্রণ করতে, টার্মিনালে "প্রতিধ্বনি $ অবস্থা" টাইপ করুন

প্রত্যাবর্তন স্থিতি 0: স্ট্যাকবল নয়

রিটার্ন স্থিতি 1: স্ট্যাকেবল

ব্যাখ্যা: স্ট্যাকের বর্তমান সর্বাধিক অঙ্কের সমতুল্য সূচকের সাথে অ্যারের উপাদান বৃদ্ধি করে। তারপরে, প্রোগ্রামটি যাচাই করে যে এইমাত্র-বর্ধিত অ্যারে উপাদানটি তার পূর্ববর্তী উপাদানগুলির চেয়ে বড় কিনা is যদি তা হয় তবে 0 প্রদান করে El অন্যথায় প্রোগ্রামটি অ্যারের শেষে 1 করে দেয় 1

 main(int argc, char ** argv)
{
    static int stack[10];

    while ( *++argv != 0x0 )
    {
        stack[**argv - 0x30]++;

        if ( **argv - 0x30 > 0 )
        {
            if ( stack[**argv - 0x30] > stack[**argv - 0x30 - 1] )
            {
                return 0;
            }

        }

    }   

    return 1;
}

3
কোড গল্ফ স্বাগতম! আপনার কোড এবং আপনার বাইকোয়েন্টের মিল থাকা উচিত, সুতরাং আপনার কোডের একটি সম্পূর্ণ গল্ফ সংস্করণ সরবরাহ করা নিশ্চিত করুন make অব্যক্ত সংস্করণটি optionচ্ছিক।
স্টিফেন

0

জেলি , 15 বাইট

œp@ŒQẎµ0rṀ⁼Qµ¿Ẹ

একটি মোনাডিক লিঙ্কটি অ-নেতিবাচক পূর্ণসংখ্যার তালিকা গ্রহণ করে এবং 0যদি স্ট্যাকযোগ্য বা 1অ-স্ট্যাকযোগ্য হয় তবে ফিরে আসে ।

এটি অনলাইন চেষ্টা করুন!

কিভাবে?

œp@ŒQẎµ0rṀ⁼Qµ¿Ẹ - Link: list
             ¿  - while loop:
      µ     µ   - ...condition chain:
       0        -      literal zero
         Ṁ      -      maximum of current list
        r       -      inclusive range = [0,1,2,...,max(list)]
           Q    -      de-duplicate list (unique values in order of appearance)
          ⁼     -      equal?
                - ...do:
   ŒQ           -      distinct sieve (1s at first occurrences 0s elsewhere)
  @             -      use swapped arguments:
œp              -        partition (the list) at truthy values (of the distinct sieve)
     Ẏ          -      tighten (makes the list flat again ready for the next loop)
              Ẹ - any truthy? 1 if the resulting list has any non-zero integers remaining
                -           - effectively isNotEmpty for our purposes since a list of only
                -             zeros gets reduced to an empty list via the loop.

আপনার পদক্ষেপ: পি: পি
লিকি নুন

হেই, আমি সন্দেহ করি আমি 11 (বা 10 ?!) কে
জোনাথন অ্যালান

0

জাপট , 16 বাইট

£=k_¥T©°T}T=0ÃUd

এটি অনলাইন পরীক্ষা! falseস্ট্যাকেবলের জন্য আউটপুট ,true অ পারে.তবে জন্য।

ব্যাখ্যা

 £   = k_  ¥ T© ° T}T=0Ã Ud
UmX{U=UkZ{Z==T&&++T}T=0} Ud    Ungolfed
                               Implicit: U = input array
UmX{                   }       For each item X in the array:
                    T=0          Set T to 0.
      UkZ{         }             Remove the items Z where
          Z==T&&++T              Z == T (and if so, increment T).
                                 This has the effect of removing the largest stack.
    U=                           Reset U to the result.
                               This process is repeated U.length times, which is
                               evidently enough to handle any U.
                         Ud    Return whether there are any truthy items in U.
                               Any items not part of a stack are non-zero/truthy,
                               so this works for every possible case.

0

05 এ বি 1 ই , 25 বাইট

ηε[DõQ#ZƒDNåiNõ.;Dëˆ#]¯OĀ

চ্যালেঞ্জটি সমস্ত কঠিন দেখাচ্ছে না, তবে এটি 05AB1E এ বেশ কঠিন (আমার পক্ষে কমপক্ষে ..)

আউটপুটগুলি 0স্ট্যাকযোগ্য এবং 1যদি স্ট্যাকেবল না হয়।

এটি অনলাইনে চেষ্টা করুন বা সমস্ত পরীক্ষার কেস যাচাই করুন

ব্যাখ্যা:

η             # Prefixes of the (implicit) input
              #  i.e. '012031' → ['0','01','012','0120','01203','012031']
              #  i.e. `021` → ['0','02','021']
 ε            # Map each to:
  [           # Start an infinite inner loop
   D          # Duplicate the current value
    õQ#       # If it's an empty String, stop the infinite loop
   Z          # Get the maximum (without popping)
              #  i.e. '01203' → 3
              #  i.e. '02' → 2
    ƒ         # Inner loop `N` in the range [0,max]
     D        # Duplicate the current value
      Nåi     # If it contains the current digit `N`
              #  i.e. '01203' and 1 → 1 (truthy)
              #  i.e. '02' and 1 → 0 (falsey)
         Nõ.; # Remove the first one (by replacing the first `N` with an empty string)
              #  i.e. '1203' and 1 → '203'
         D    # And duplicate it again for the next iteration of the inner loop
      ë       # Else (does not contain the digit `N`):
       ˆ      # Push `N` to the global stack
        #     # And break the infinite loop
 ]            # Close the if-else, inner loop, infinite loop, and mapping (short for `}}}}`)
  ¯           # Push the global stack
   O          # Take the sum
              #  i.e. [] → 0
              #  i.e. ['2'] → 2
    Ā         # And get the trutified value of that (which we implicitly output as result)
              #  i.e. 0 → 0
              #  i.e. 2 → 1

0

জাভা 8, 87 বাইট

স্ট্যাকগুলি তৈরি করার পরিবর্তে আমি কেবলমাত্র গণনা করি যদি কোনও উপাদান পূর্ববর্তী উপাদানগুলিতে অস্থির হয়ে থাকে তবে 0 টি ফিরে আসি এবং যখন কোনও অস্থির অযোগ্য উপাদান সম্মুখীন হয়। যদি আমি শেষের দিকে পৌঁছে যাই তবে পুরো স্ট্রিংটি স্ট্যাকযোগ্য এবং 1 টি ফিরে আসে:

s->{int l[]=new int[10];for(int n:s)if(n!=0&&l[n]>=l[n-1]||l[n]++<0)return 0;return 1;}

এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা:

s->{
  int l[]=new int[10];                # initialise the counts of each digit encountered prefix of element, all initialised to 0
  for(int n:s)                        # Iterate over all entries in input
    if(n!=0&&l[n]>=l[n-1]||++l[n]<0)  # Check if the element is stackable on the previous elements. Last check is always evaluated and false, but the sideeffect is to add the element to the handled, prefixed element og the next element.  
      return 0;                       # Unstackable
  return 1;                           # No unstackable elements, so the result is stackable
}
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.