직무

f-x = x % a ₁  % a ₂  %… % a _k 의 함수로 mod-fold 를 정의합니다 . 여기서 a _i 는 양의 정수이고 k ≥ 0 입니다. (여기서 % 는 왼쪽 연관 모듈로 연산자입니다.)

n 개의 정수 y ₀ ,…, y _n-1 의 목록이 주어지면 각 겹침 f 가 존재하는지 확인 하여 각 y _i  = f (i)가되도록하십시오 .

기능 / 프로그램에 대해 두 개의 출력 Y 및 N 을 선택하고 수정할 수 있습니다 . 이러한 f 가 존재 하면 항상 정확히 Y를 반환 / 인쇄해야합니다 . 그렇지 않은 경우 항상 정확히 N을 반환 / 인쇄해야합니다 . (이것은 true/ false, 1/ 0, 또는 false/ true등일 수 있습니다 .) 대답에 이것을 언급하십시오.

바이트 단위의 최단 제출이 이깁니다.

예

정의 F (x)는 X % 7 % 3 =를 . 그 값은 다음과 같이 시작됩니다.

|   x  | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | ...
| f(x) | 0 | 1 | 2 | 0 | 1 | 2 | 0 | 0 | 1 | 2 | ...

따라서 0 1 2 0 1 2 0 0 1 2솔루션에 입력으로 주어지면 이 f 가 해당 시퀀스를 생성 하므로 Y를 인쇄 합니다. 그러나 입력으로 주어진 경우 f 는 해당 시퀀스를 생성 하지 않으므로 N 을 인쇄 합니다.0 1 0 1 2

테스트 사례

출력이 Y 일 때 주어진 공식 은 단지 참조 용입니다. 아무 때나 인쇄해야합니다.

0 1 2 3 4 5              Y    (x)
1                        N
0 0 0                    Y    (x%1)
0 1 2 0 1 2 0 0 1 2      Y    (x%7%3)
0 0 1                    N
0 1 2 3 4 5 6 0 0 1 2    Y    (x%8%7)
0 1 2 0 1 2 0 1 2 3      N
0 2 1 0 2 1 0 2 1        N
0 1 0 0 0 1 0 0 0 0 1    Y    (x%9%4%3%2)

Pyth, 14 바이트

}Qm%M+RdUQy_Sl

를 반환 True/False합니다. 온라인으로 사용해보십시오 : 데모 또는 테스트 스위트

설명:

}Qm%M+RdUQy_SlQ   implicit Q (=input) at the end
             lQ   length of input list
            S     create the list [1, 2, ..., len]
           _      reverse => [len, ..., 2, 1]
          y       generate all subsets (these are all possible mod-folds)
  m               map each subset d to:
        UQ           take the range [0, 1, ..., len-1]
     +Rd             transform each number into a list by prepending it to d
                     e.g. if mod-fold = [7,3], than it creates:
                        [[0,7,3], [1,7,3], [2,7,3], [3,7,3], ...]
   %M                fold each list by the modulo operator
                  this gives all possible truthy sequences of length len
}Q                so checking if Q appears in the list returns True or False

Pyth, 11 바이트

q%M.e+k_tx0

@ferrsum의 아이디어를 기반으로 합니다. 실제로 서브셋 생성에 0 표시를 사용하는 것에 대해 생각했지만 모든 0 표시가 이미 솔루션이어야한다는 것을 알지 못했습니다.

파이썬 3, 239 218 바이트

from itertools import*
lambda z:z in[[eval(''.join([str(l)]+['%'+str(i[::-1][k])for k in range(len(i))]))for l in range(len(z))]for i in(i for j in(combinations(range(1,len(z)+1),i+1)for i in range(len(z)))for i in j)]

목록을 입력 z하고 True또는 Falsefor Y및 for를 반환 하는 익명 함수입니다 N.

이것은 @Jakube의 대답 과 비슷한 방법을 사용하며 본질적으로 무차별 적이지만 매우 빠르게 실행됩니다.

from itertools import*               Import everything from the Python module for
                                     iterable generation
lambda z                             Anonymous function with input list z
combinations(range(1,len(z)+1),i+1)  Yield all sorted i+1 length subsets of the range
                                     [1,len(z)]...
...for i in range(len(z))            ...for all possible subset lengths
(i for j in(...)for i in j)          Flatten, yielding an iterator containing all possible
                                     mod-fold values as separate lists
...for i in...                       For all possible mod-fold values...
...for k in range(len(i))            ...for all mod-fold values indices k...
...for l in range(len(z))            ...for all function domain values in [0,len(z)-1]...
[str(l)]+['%'+str(i[::-1][k])...]    ...create a list containing each character of the
                                     expression representing the function defined by the
                                     mod-fold values (reversed such that the divisors
                                     decrease in magnitude) applied to the domain value...
 eval(''.join(...))                  ...concatenate to string and evaluate...
 [...]                               ...and pack all the values for that particular
                                     function as a list
 [...]                               Pack all lists representing all functions into a list
 ...:z in...                         If z is in this list, it must be a valid mod-fold, so
                                     return True. Else, return False

Ideone에서 사용해보십시오

파이썬 2, 69 바이트

f=lambda a,i=0:i/len(a)or a[i]in[a[i-1]+1,i,0][i<=max(a)::2]*f(a,i+1)

True/를 사용합니다 False.

mod-foldable 시리즈의 특징에 대한 대답은 처음에 보이는 것보다 덜 흥미 롭습니다. 0, 1, ..., M-1, 0, 1, ... x ₁ , 0, 1, ..., x ₂ 등 의 일련의 형식입니다. <= x _i <M. 이러한 시퀀스는 첫 번째를 제외하고 배열에서 0의 모든 (0 기반) 인덱스의 mod 체인에 의해 생성 될 수 있습니다.

젤리 , 19 15 14 바이트

LṗLUZ’1¦%/sLe@

반환 1 truthy를 들어, 0 falsy합니다. 온라인으로 사용해보십시오!

알고리즘은 O (n ⁿ ) 이며, 여기서 n 은 목록의 길이이므로 대부분의 테스트 사례에서 너무 느리고 메모리 집약적입니다.

두 번째 버전 L을 a로 바꾸는 수정 된 버전을 5사용하여 모든 테스트 사례 를 확인할 수 있습니다 . 이 수정 된 버전은 임의로 긴 목록에는 작동하지 않습니다.

작동 원리

LṗLUZ’1¦%/sLe@  Main link. Argument: A (array of integers)

L L             Yield the length l of A.
 ṗ              Take the l-th Cartesian power of [1, ..., l], i.e., construct
                all arrays of length l that consist of elements of [1, ..., l].
   U            Upend/reverse each array. This way, the first l arrays start
                with [1, ..., l], as do the next l arrays, etc.
    Z           Zip/transpose the array of arrays.
     ’1¦        Decrement the first array to map [1, ..., l] to [0, ..., l - 1].
        %/      Reduce the array's columns by modulus/residue.
          sL    Split the result into chunks of length l.
            e@  Verify if A belongs to the resulting array.

JavaScript (ES6), 98 바이트

a=>a.every((n,i)=>n?n<(l+=p==i)&&n==p++:p=1,l=p=1)

@Feersum의 검색으로 전환하여 48 바이트를 절약했습니다. n배열의 지정된 값 은 0입니다.이 경우 다음 예측 p은 1이거나 다음 예측과 같으며이 경우 p증분됩니다. 또한 항상 항상보다 작아야 하기 때문에와 l비교하여 초기 시퀀스 의 길이 를 측정합니다 .pinl

파이썬 2, 103 99 바이트

f=lambda l,r:r==x or l and f(l-1,[t%l for t in r])|f(l-1,r)
x=input();l=len(x);print+f(l,range(l))

1 을 진솔하게 표시하고 0 을 거짓으로 인쇄합니다 . Ideone에서 테스트하십시오 .