আপনার সংখ্যা দ্বারা আপনার সংখ্যা সীমাবদ্ধ

15

স্ব-সীমাবদ্ধ তালিকাগুলি

Nonnegative পূর্ণসংখ্যাসমূহের একটি অমানবিক তালিকা এল বিবেচনা করুন । একটি রান মধ্যে এল সমান উপাদান, যা আর করা যাবে না একটি সংলগ্ন sublist হয়। উদাহরণস্বরূপ, [0,0,1,1,3,3,3,2,1,1] এর রানগুলি [0,0], [1,1], [3,3,3], [2 ], [1,1] । তালিকা এল হয় স্ব সীমিত যদি প্রতিটি পূর্ণসংখ্যা জন্য এন ≥ 1 , ঘটনার সংখ্যা এন কম বা এর রানের সংখ্যা সমান এন -1 । উপরের তালিকাটি স্ব-সীমাবদ্ধ নয়, কারণ এখানে 1 টির 4 টি ঘটনা রয়েছে , তবে 0 টির মধ্যে কেবল একটি রান run

এখানে স্ব-সীমাবদ্ধ তালিকার একটি উদাহরণ রয়েছে: [0,0,3,4,1,0,2,1,1,0,2,1,0,0,0,1,0] । ইহা ছিল

  • 5 রানে 0 5 ঘটনার এবং 1 ,
  • 1 এর 4 রান এবং 2 টির 2 টি ইভেন্ট ,
  • 2 রান 2 এবং 1 টি সংঘটন 3 ,
  • 3 এর 1 রান এবং 1 টি 4 এর উপস্থিতি ,
  • 1 রান 4 এবং কোন ঘটনার 5 ,
  • অন্যান্য পূর্ণসংখ্যার কোনও ঘটনা নেই।

কাজটি

আপনার কাজটি কোনও তালিকা স্ব-সীমাবদ্ধ কিনা তা সিদ্ধান্ত নেওয়া। আরও স্পষ্টতই, আপনার ইনপুটটি nonnegative পূর্ণসংখ্যার একটি দুর্দান্ত কিছু তালিকা হবে। যদি তালিকাটি স্ব-সীমাবদ্ধ থাকে তবে আপনার আউটপুট সত্যবাদী হবে; অন্যথায়, এটি মিথ্যা হবে। ইনপুট এবং আউটপুট যে কোনও যুক্তিসঙ্গত বিন্যাসে হতে পারে।

প্রতিটি প্রোগ্রামিং ভাষার সর্বনিম্ন বাইট গণনাটি বিজয়ী স্ট্যান্ডার্ড কোড-গল্ফ বিধি প্রযোজ্য।

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

সত্য ঘটনা:

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

মিথ্যা উদাহরণ:

[2]
[1,1,0]
[0,0,1,1,1,0,0,2]
[0,1,0,1,1,2,2,3,0,0,4,6]
[1,1,2,1,2,0,2,0,3,0,0,2,2,1,2,3,2,0,1,1,1,0,0,3,3,0]
[3,4,1,0,0,0,5,5,0,2,2,0,0,0,0,0,2,0,1,1,0,4,3,5,4,3]
[1,0,0,0,2,5,3,1,1,0,3,3,1,3,5,4,0,4,0,0,2,0,2,1,1,5,0,0,2,4,4,0,2,0,1,4,4,2,3,3,5,3,4,0,2,0,5]
[4,3,1,0,0,4,6,6,1,0,1,2,1,3,0,1,0,2,0,3,4,0,2,1,1,3,0,2,2,2,0,5,5,0,5,2,5,5,0,4,3,2,3,1,1,3,5,1,4,1,6,2,6,2,4,0,4,0,4,5,3,3,0,0,6,1,0,0,0,6,2,1,0,1,2,6,2,4]
[5,1,1,1,0,2,0,6,1,0,2,1,2,2,5,3,1,0,0,0,3,2,3,0,1,1,0,1,0,1,1,2,0,6,4,1,2,1,1,6,4,1,2,2,4,0,1,2,2,1,3,0,1,2,0,0,0,2,0,2,2,0,1,0,0,1,3,0,0,0,6,2,0,1,0,1,2,1,1,1,0,4,0,0,5,2,0,0,0,4,1,2,2,2,2,0,5,3,2,4,5,0,5]
code-golf  array-manipulation  decision-problem 
— Zgarb
সূত্র
মাথা ঘামানোর মতো নয় , তবে দয়া করে সত্যতা / মিথ্যা বলার পরিবর্তে এই মেটা আলোচনা থেকে একটি পদ্ধতির ব্যবহার বিবেচনা করুন , কারণ সত্যতা এখানে প্রায়শই ব্যবহৃত বেশ কয়েকটি ভাষার চেয়ে বেশি সম্পত্তি নয়।
— FryAmTheEggman
@ ল্যাকিয়ুন হ্যাঁ, অন্যথায় শর্তটি এন এন-এর জন্য উপস্থিত নয় এমন এনগুলির জন্য ব্যর্থ হয়।
— Zgarb
@ মিঃ এক্সকোডার এখানেও রয়েছে [2], তবে এই জাতীয় ঘটনাগুলি মিথ্যা বলা উচিত, হ্যাঁ।
— এরিক আউটগল্ফার
@ ফ্রাইআম দ্য এজিগম্যান আমি যে আলোচনাটি দেখিনি, এটি লিঙ্ক করার জন্য ধন্যবাদ। আমি যদিও এই চ্যালেঞ্জটি ঠিক তেমনি রাখব, কারণ আমি সেখানে আলোচিত পন্থাগুলি কিছু সময়ের জন্য প্রক্রিয়া করতে চাই।
— Zgarb
অবশ্যই, তবে আমি মন্তব্যটি সেখানে রাখতে চাই, যেহেতু আমার মনে হচ্ছে অনেক লোক এটি মিস করেছেন। কমপক্ষে আমার জন্য, রেটিনার মতো ভাষায় পোস্ট করার ক্ষেত্রে এটি বেশ গুরুত্বপূর্ণ।
— FryAmTheEggman

উত্তর:

5

পার্ল 6 , 29 বাইট

{bag(.grep(?*)X-1)⊆.squish}

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

পার্ল for এর জন্য খুব দুর্দান্ত চ্যালেঞ্জ ব্যাগে সাবগেট অপারেটর ব্যবহার করে (পূর্ণসংখ্যা-ভারিত সেট)। ব্যাখ্যা:

{
    bag(           # Create bag of
        .grep(?*)  # non-zero elements,
        X- 1       # decremented by one.
    )
    ⊆              # Subset test.
    .squish        # "squish" removes repeated elements in each run.
                   # The result is implicitly converted to a bag
                   # counting the number of runs.
}
— nwellnhof
সূত্র
1
সুন্দর। আমি ব্যাগ + সাবসেটের পন্থা দেখেছি কিন্তু তুলনায় জিনিসটিতে আটকেছি।
— ফিল এইচ
3

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

a=>a.map(n=>g(~n,n!=p&&g(p=n)),c=[j=0],p=g=n=>c[n]=-~c[n])&&!c.some((n,i)=>i-j++|n<c[~j])

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

কিভাবে?

অ্যারের সি [] রান সংখ্যা এবং পূর্ণসংখ্যার উপস্থিতি সংখ্যা উভয়ই সঞ্চয় করতে ব্যবহৃত হয়। রানগুলি অ-নেতিবাচক সূচকগুলিতে সংরক্ষণ করা হয় এবং পূর্ণসংখ্যার ঘটনাগুলি 1 এর পরিপূরক সূচকগুলিতে সংরক্ষণ করা হয় ( সি [-1] = 0 এর সংখ্যার , সি [-2] = 1 এর সংখ্যা ইত্যাদি)।

Gণাত্মক সূচকগুলি প্রকৃতপক্ষে অন্তর্নিহিত অ্যারে অবজেক্টের বৈশিষ্ট্য হিসাবে সংরক্ষণ করা হয় এবং .some () তাদের উপরে পুনরাবৃত্তি করে না।

a =>                        // given the input array a[]
  a.map(n =>                // for each value n in a[]:
    g(                      //   update c[]:
      ~n,                   //     increment c[~n] (# of integer occurrences)
      n != p && g(p = n)    //     if n != p, set p to n and increment c[n] (# of runs)
    ),                      //   end of c[] update
    c = [j = 0],            //   start with c = [0] and j = 0 (used later)
    p =                     //   initialize p to a non-numeric value
    g = n => c[n] = -~c[n]  //   g = helper function to increment c[n]
  )                         // end of map()
  && !c.some((n, i) =>      // for each value n at position i in c[]:
    i - j++ |               //   make sure that i == j++
    n < c[~j]               //   and n is greater than or equal to c[~j]
  )                         // end of some()
— Arnauld
সূত্র
3

জেলি , 10 বাইট

œ-ŒgḢ€‘ƊS¬

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

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

œ-ŒgḢ€‘ƊS¬  Main link. Argument: A (array)

       Ɗ    Drei; group the three links to the left into a monadic chain.
  Œg          Group consecutive, identical elements of A into subarrays.
    Ḣ€        Head each; pop the first element of each run.
      ‘       Increment the extracted integers.
            The resulting array contains n repeated once for each run of (n-1)'s.
œ-          Perform multiset subtraction, removing one occurrence of n for each
            run of (n-1)'s.
       S    Take the sum. If only 0's remain, the sum will be 0.
        ¬   Take the logical NOT, mapping 0 to 1 and positive integers to 0.
— ডেনিস
সূত্র
2

স্ট্যাক্স , 13 9 বাইট

ডেনিস আরও ভাল একটি অ্যালগরিদম খুঁজে পেলেন । আমি নির্লজ্জভাবে স্ট্যাক্স এ পোর্ট করেছি।

ä╨²@┬↕OR♣

এটি চালান এবং অনলাইনে ডিবাগ করুন

আনপ্যাকড, অবরুদ্ধ এবং মন্তব্য করেছে, এটি দেখতে এটির মতোই like

c   copy input
:g  get run elements
{^m increment each
|-  multiset-subtract from original input
|M! get maximum from result, and apply logical not

এটি চালান

পুরানো উত্তর:

║Ä|╤#╫∩▼cëózü

এটি চালান এবং এটি ডিবাগ করুন

এটি ইনপুটটির পুনরাবৃত্তি করে এবং শর্তাদি পরীক্ষা করে:

  • উপাদানটি কি > 0?
  • হয় occurrences(element) >= runs(element - 1)?

যদি এই শর্তগুলির কোনওটি যদি কোনও উপাদানের পক্ষে সত্য হয় তবে সেই উপাদানটি সামঞ্জস্যপূর্ণ। যদি সমস্ত উপাদান অনুগত হয় তবে ফলাফল হয় 1।

এখানে আনপ্যাকড, অসম্পূর্ণ, একই প্রোগ্রামটির উপস্থাপনের মন্তব্য দেওয়া হয়েছে।

O           push 1 under the input
F           iterate over the input using the rest of program
  |c        skip this iteration of the value is 0
  x#        number of occurrences of this value in input (a)
  x:g _v#   number of runs of (current-1) in input (b)
  >!        not (a > b); this will be truthy iff this element is compliant
  *         multiply with running result

এটি চালান

— পুনরাবৃত্তি
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.