Kendi kendini sınırlayan listeler

Negatif olmayan tamsayılar içeren boş bir liste L düşünün . Bir çalışma içinde L daha uzun yapılamaz eşit olan bir eleman, bir bitişik alt listesini olup. Örneğin, [0,0,1,1,3,3,3,2,1,1] değerleri [0,0], [1,1], [3,3,3], [2'dir. ], [1,1] . Liste L olan kendi kendini sınırlayan her tam sayı için ise N ≥ 1 , ortaya çıkma sayısı N ishal sayısına eşit veya bundan daha az olan bir N-1 . Yukarıdaki liste kendi kendini sınırlamaz, çünkü 1'in 4 tekrarı vardır , ancak 0 saniyeden sadece bir çalışma vardır .

İşte kendi kendini sınırlayan bir liste örneği: [0,0,3,4,1,0,2,1,1,0,2,1,0,0,0,1,0] . Vardır

• 0'dan 5 çalışma ve 1'den 5 tekrarlama ,
• 4 çalışır 1 ve 2 oluşumları 2 ,
• 2 çalışır 2 ve 1 tekrardan 3 ,
• 3'ün 1 koşusu ve 4'ün 1 oluşumu ,
• 4'ün 1 koşusu ve 5'in hiçbir tekrarlaması yok ,
• diğer tamsayıların oluşumu.

Görev

Göreviniz bir listenin kendi kendini sınırlayıp sınırlamadığına karar vermektir. Daha açık bir şekilde, girdiniz negatif olmayan tam sayıların boş olmayan bir listesi olacaktır. Liste kendi kendini sınırlarsa, çıktınız doğrudur; aksi taktirde sahte olur. Giriş ve çıkış herhangi bir makul formatta olabilir.

Her programlama dilinde en düşük bayt sayısı kazanır. Standart kod golf kuralları geçerlidir.

Test senaryoları

Gerçek örnekler:

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

Falsy örnekleri:

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

Perl 6 , 29 bayt

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

Çevrimiçi deneyin!

Perl 6 için çok güzel bir meydan okuma Torbalardaki altküme operatörünü kullanır (tamsayı ağırlıklı kümeler). Açıklama:

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

JavaScript (ES6), 92 89 bayt

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

Çevrimiçi deneyin!

Nasıl?

C [] dizisi hem çalışma sayısını hem de tamsayı tekrar sayısını depolamak için kullanılır. İşlemler negatif olmayan indekslerde saklanır ve tamsayı oluşumları 1'in tamamlayıcı indekslerinde saklanır ( c [-1] = 0 sayısı , c [-2] = 1 sayısı vb.).

Negatif dizinler aslında temel alınan dizi nesnesinin özellikleri olarak kaydedilir ve .some () bunların üzerinde yinelenmez.

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

Perl 5 -p , 49 48 44 bayt

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

Çevrimiçi deneyin!

Jöle , 10 bayt

œ-ŒgḢ€‘ƊS¬

Çevrimiçi deneyin!

Nasıl çalışır

œ-Œ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.

Jöle , 19 bayt

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

Çevrimiçi deneyin!

Jöle , 17 bayt

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

Çevrimiçi deneyin!

Python 3 , 94 bayt

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

Çevrimiçi deneyin!

Japt , 21 bayt

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

Çevrimiçi test edin!

Stax , 13 9 bayt

Dennis çok daha iyi bir algoritma buldu . Utanmadan stax'a taşıdım.

ä╨²@┬↕OR♣

Çevrimiçi çalıştırın ve hata ayıklayın

Ambalajından çıkarılmış, golf edilmemiş ve yorumlanmış gibi görünüyor.

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

Bunu çalıştır

Eski Cevap:

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

Çalıştır ve hata ayıkla

Girdiyi yineler ve koşulları kontrol eder:

• Öğe > 0mi?
• Öyle occurrences(element) >= runs(element - 1)mi?

Bu koşullardan herhangi biri bir öğe için geçerliyse, o öğe uyumludur. Tüm elemanlar uyumluysa sonuç 1.

İşte aynı programın ambalajsız, ungolfed, yorumlanmış temsili.

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

Bunu çalıştır

Haskell, 80 bayt

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

Çevrimiçi deneyin!