Danh sách tự giới hạn

Hãy xem xét một danh sách không trống L chứa các số nguyên không âm. Một lần chạy trong L là một danh sách con liền kề của các phần tử bằng nhau, không thể thực hiện lâu hơn. Ví dụ: các lần chạy của [0,0,1,1,3,3,3,2,1,1] là [0,0], [1,1], [3,3,3], [2 ], [1,1] . Danh sách L là tự giới hạn nếu cho mỗi số nguyên N ≥ 1 , số lần xuất hiện của N là nhỏ hơn hoặc bằng với số chạy của N-1 . Danh sách trên không tự giới hạn, vì có 4 lần xuất hiện 1 , nhưng chỉ có một lần chạy 0 s.

Đây là một ví dụ về danh sách tự giới hạn: [0,0,3,4,1,0,2,1,1,0,2,1,0,0,0,1,0] . Nó có

• 5 lần chạy 0 và 5 lần xuất hiện của 1 ,
• 4 lần chạy 1 và 2 lần xuất hiện của 2 ,
• 2 lần chạy 2 và 1 xảy ra 3 ,
• 1 lần chạy 3 và 1 lần xuất hiện của 4 ,
• 1 chạy 4 và không có sự xuất hiện của 5 ,
• không có sự xuất hiện của các số nguyên khác.

Nhiệm vụ

Nhiệm vụ của bạn là quyết định xem một danh sách có tự giới hạn hay không. Rõ ràng hơn, đầu vào của bạn sẽ là một danh sách không chứa các số nguyên không âm. Nếu danh sách là tự giới hạn, đầu ra của bạn sẽ là trung thực; nếu không, nó sẽ là giả. Đầu vào và đầu ra có thể ở bất kỳ định dạng hợp lý.

Số byte thấp nhất trong mỗi ngôn ngữ lập trình là người chiến thắng. Mã tiêu chuẩnLuật áp dụng.

Các trường hợp thử nghiệm

Trường hợp thật

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

Trường hợp giả mạo:

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

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

Hãy thử trực tuyến!

Thử thách rất hay cho Perl 6. Sử dụng toán tử tập hợp con trên Túi (bộ có trọng số nguyên). Giải trình:

{
    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 byte

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

Hãy thử trực tuyến!

Làm sao?

Mảng c [] được sử dụng để lưu trữ cả số lần chạy và số lần xuất hiện số nguyên. Các lần chạy được lưu trữ tại các chỉ số không âm và các lần xuất hiện số nguyên được lưu trữ tại các chỉ số bổ sung của 1 ( c [-1] = số 0 's, c [-2] = số 1 ' s, v.v.).

Các chỉ mục phủ định thực sự được lưu dưới dạng các thuộc tính của đối tượng mảng bên dưới và .some () không lặp lại trên chúng.

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 byte

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

Hãy thử trực tuyến!

Thạch , 10 byte

œ-ŒgḢ€‘ƊS¬

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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

Thạch , 19 byte

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

Hãy thử trực tuyến!

Thạch , 17 byte

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

Hãy thử trực tuyến!

Python 3 , 94 byte

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

Hãy thử trực tuyến!

Japt , 21 byte

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

Kiểm tra nó trực tuyến!

Stax , 13 9 byte

Dennis tìm thấy một thuật toán tốt hơn nhiều . Tôi đã xấu hổ chuyển nó sang stax.

ä╨²@┬↕OR♣

Chạy và gỡ lỗi trực tuyến

Giải nén, không được chỉnh sửa và nhận xét, đây là những gì nó trông giống như.

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

Chạy cái này

Câu trả lời cũ:

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

Chạy và gỡ lỗi nó

Nó lặp lại qua đầu vào và kiểm tra các điều kiện:

• Là yếu tố > 0 ?
• Là occurrences(element) >= runs(element - 1)?

Nếu một trong hai điều kiện này đúng với một phần tử, thì phần tử đó tuân thủ. Nếu tất cả các yếu tố đều tuân thủ, kết quả là1 .

Đây là đại diện được giải nén, không ghi chú, bình luận của cùng một chương trình.

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

Chạy cái này

Haskell, 80 byte

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

Hãy thử trực tuyến!