자체 제한 목록

음수가 아닌 정수를 포함 하는 비어 있지 않은 목록 L 을 고려하십시오 . 실행 에서 L은 더 이상 할 수 없다 동일한 요소의 연속 하위 목록입니다. 예를 들어, [0,0,1,1,3,3,3,2,1,1] 의 런 은 [0,0], [1,1], [3,3,3], [2 ], [1,1] . 리스트 L 은 각 정수 N ≥ 1 에 대해 N 발생 횟수가 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 과 2의 2 번의 4 회 실행 ,
• 2 런 2 및 1 명의 발생 3 ,
• 1 개 실행 3 및 1 명 발생 4 ,
• 4의 1 런 , 5의 발생 없음 ,
• 다른 정수는 발생하지 않습니다.

작업

당신의 임무는 목록이 자체 제한인지 여부를 결정하는 것입니다. 보다 명확하게, 입력은 음이 아닌 정수의 비어 있지 않은 목록이어야합니다. 리스트가 자체 제한적이라면, 당신의 결과는 진실해야합니다; 그렇지 않으면 허위가됩니다. 입력 및 출력은 임의의 합리적인 형식 일 수 있습니다.

각 프로그래밍 언어에서 가장 낮은 바이트 수가 승자입니다. 표준 코드 골프 규칙이 적용됩니다.

테스트 사례

진실한 사례 :

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

펄 6 , 29 바이트

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

온라인으로 사용해보십시오!

Perl 6에게는 매우 어려운 과제입니다. Bag에 서브 세트 연산자를 사용합니다 (정수 가중치 세트). 설명:

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

자바 스크립트 (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])

온라인으로 사용해보십시오!

어떻게?

c [] 배열 은 실행 횟수와 정수 발생 횟수를 모두 저장하는 데 사용됩니다. 런은 음이 아닌 인덱스에 저장되고 정수 발생은 1의 보수 인덱스에 저장됩니다 ( c [-1] = 0 수 , c [-2] = 1 수 등).

음수 인덱스는 실제로 기본 배열 객체의 속성 으로 저장되며 .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()

펄 5 -p , 49 48 44 바이트

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

온라인으로 사용해보십시오!

젤리 , 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.

젤리 , 19 바이트

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

온라인으로 사용해보십시오!

젤리 , 17 바이트

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

온라인으로 사용해보십시오!

파이썬 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)))

온라인으로 사용해보십시오!

Japt , 21 바이트

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

온라인으로 테스트하십시오!

Stax , 13 9 바이트

Dennis 는 훨씬 더 나은 알고리즘을 발견했습니다 . 나는 그것을 뻔뻔스럽게 stax에 포팅했습니다.

ä╨²@┬↕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)?

요소에 대해 이러한 조건 중 하나에 해당하면 해당 요소가 준수하는 것입니다. 모든 요소가 호환되면 결과는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

이것을 실행

하스켈, 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]

온라인으로 사용해보십시오!