अपने रनों द्वारा अपनी संख्या सीमित करें

Question

स्व-सीमित सूची

एक गैर-रिक्त सूची L पर विचार करें जिसमें nonnegative पूर्णांक हैं। L में एक रन समान तत्वों का एक सन्निहित उप-समूह है, जिसे अधिक समय तक नहीं बनाया जा सकता है। उदाहरण के लिए, के रन [0,0,1,1,3,3,3,2,1,1] कर रहे हैं [0,0], [1,1], [3,3,3], [2 ], [११ ९] । सूची एल है स्वयं को सीमित करता है, तो प्रत्येक पूर्णांक के लिए एन ≥ 1 , की पुनरावृत्ति की संख्या एन से कम या के रनों की संख्या के बराबर है N-1 । उपरोक्त सूची स्व-सीमित नहीं है, क्योंकि 1 की 4 घटनाएं हैं , लेकिन केवल 0 में से एक रन है ।

यहाँ स्व-सीमित सूची का एक उदाहरण दिया गया है: [0,0,3,4,1,0,2,1,1,0,2,1,0,0,0,1,0] । यह है

• की 5 रन 0 से 5 की आवृत्तियां और 1 ,
• 4 रन 1 और 2 घटनाओं 2 ,
• की 2 रन 2 और 1 घटना 3 ,
• की 1 रन 3 और 1 घटना 4 ,
• 4 का 1 रन और 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]

Comments

परेशान होने की बात नहीं है, लेकिन कृपया सत्य / मिथ्या के बजाय इस मेटा चर्चा में से किसी एक दृष्टिकोण का उपयोग करने पर विचार करें , क्योंकि सत्यता अक्सर यहां इस्तेमाल होने वाले युगल भाषाओं से अधिक की संपत्ति नहीं है।

— FryAmTheEggman

@LeakyNun हां, अन्यथा स्थिति उन N के लिए विफल हो जाती है जिनके लिए N-1 मौजूद नहीं है।

— जरगब

@ Mr.Xcoder वहाँ [2]भी है, लेकिन इस तरह के मामलों को झूठा होना चाहिए, हाँ।

— एर्गेल्फ़र

@FryAmTheEggman मैंने उस चर्चा को नहीं देखा था, इसे जोड़ने के लिए धन्यवाद। मैं इस चुनौती को वैसे ही रखूंगा, क्योंकि मैं कुछ समय के लिए वहां चर्चा के तरीकों को संसाधित करना चाहता हूं।

— जरगब

ज़रूर, लेकिन मैं वहाँ टिप्पणी रखना चाहूंगा, क्योंकि मुझे लगता है कि बहुत से लोगों ने इसे याद किया है। यह बहुत मायने रखता है, कम से कम मेरे लिए, रेटिना जैसी भाषाओं में पोस्टिंग में।

— FryAmTheEggman

Answer 1

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

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

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

पर्ल के लिए बहुत अच्छी चुनौती 6. बैग (पूर्णांक भार वाले सेट) पर सबसेट ऑपरेटर का उपयोग करता है । स्पष्टीकरण:

{
    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.
}

Comments

सुंदर। मैंने थैला + उप-दृष्टिकोण देखा लेकिन तुलना करने की बात पर अड़ गया।

— फिल एच

Answer 2

जावास्क्रिप्ट (ईएस 6), 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])

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

कैसे?

सरणी c [] का उपयोग रन की संख्या और पूर्णांक घटनाओं की संख्या दोनों को संग्रहीत करने के लिए किया जाता है। रन को गैर-नकारात्मक सूचकांकों पर संग्रहीत किया जाता है और पूर्णांक आवृत्तियों को 1-पूरक सूचकांकों ( c [-1] = 0 की संख्या , c [-2] = 1 's की संख्या , आदि) में संग्रहीत किया जाता है ।

नकारात्मक सूचकांकों को वास्तव में अंतर्निहित सरणी वस्तु के गुणों के रूप में सहेजा जाता है और .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()

Answer 3

पर्ल 5 -p , 49 48 44 बाइट्स

#!/usr/bin/perl -p
$z[$_+1]+=!/^$o$/;$z[$o=$_]--}{$_="@z"!~/.-/

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

Answer 4

जेली , 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.

Answer 5

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

ŒgḢ€ċЀṀḶ$<ċЀṀR$$Ẹ

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

Answer 6

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

ŒgḢ€ċ’}<ċ
çЀx⁸ẸṆ

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

Answer 7

पायथन 3 , 94 बाइट्स

lambda a:all(sum(1for x,y in zip(a,a[1:]+[-1])if x==j!=y)>=a.count(j+1)for j in range(max(a)))

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

Comments

sum(1for ... if x==j!=y)=> sum(x==j!=y for ...)।

— मिस्टर एक्सकोडर

@ Mr.Xcoder ओह toc। धन्यवाद!

— हाइपरनेत्रिनो

Answer 8

जाप , 21 बाइट्स

x o e@ó¥ mÌè¥X ¨Uè¥XÄ

इसे ऑनलाइन टेस्ट करें!

Answer 9

स्टैक्स , 13 9 बाइट्स

डेनिस को एक बेहतर एल्गोरिथ्म मिला । मैंने बेशर्मी से इसे स्टैक्स में डाल दिया।

ä╨²@┬↕OR♣

इसे ऑनलाइन चलाएं और डीबग करें

अनपैक्ड, अनगुल्फेड, और टिप्पणी की, यह वही है जो ऐसा दिखता है।

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)?

यदि किसी तत्व के लिए ये दोनों स्थितियाँ सत्य हैं, तो वह तत्व आज्ञाकारी है। Iff सभी तत्व आज्ञाकारी हैं, परिणाम है 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

इसको चलाओ

Answer 10

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

import Data.List
o#l=[1|x<-l,x==o]
f x=and[(i-1)#(head<$>group x)>=i#x|i<-x,i>0]

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