요약 : 정수의 입력 시퀀스가 ​​"허용 가능한지"여부를 테스트합니다. 이는 모듈러스에 대한 모든 잔류 물 클래스를 포함하지는 않습니다.

"허용 가능한"순서는 무엇입니까?

정수 m ≥ 2 인 경우, 잔류 물 클래스 모듈로 m 은 공통 차이 m의 가능한 산술 진행률입니다. 예를 들어, m = 4 인 경우, 4 잔기 클래스 모듈로 4는

..., -8, -4, 0, 4, 8, 12, ...
..., -7, -3, 1, 5, 9, 13, ...
..., -6, -2, 2, 6, 10, 14, ...
..., -5, -1, 3, 7, 11, 15, ...

k 번째 잔기 부류는 m으로 나눈 나머지가 k와 같은 모든 정수로 구성된다. (음수에 대해 "나머지"를 올바르게 정의하는 한)

정수 a1, a2, ..., ak의 시퀀스는 적어도 하나의 잔기 클래스와 교차하지 않으면 허용되는 모듈로 m 입니다. 예를 들어, {0, 1, 2, 3} 및 {-4, 5, 14, 23}이다 하지 허용 모듈 4 있지만 {0, 1, 2, 4} 및 {0, 1, 5, 9}이고 {0, 1, 2, -3} 은 허용 가능한 모듈로 4입니다. 또한 {0, 1, 2, 3, 4}는 허용 가능한 모듈로 4 가 아니며 {0, 1, 2} 는 허용 가능한 모듈로 4입니다.

마지막으로, 정수 m ≥ 2마다 모듈로 m이 허용 되는 경우 정수 시퀀스가 허용 됩니다.

도전

입력으로 정수 시퀀스를 취하는 프로그램이나 함수를 작성하고 시퀀스가 ​​허용되면 (일관된) Truthy 값을, 시퀀스가 ​​허용되지 않으면 (일관된) Falsy 값을 반환합니다.

정수의 입력 순서는 적절한 형식 일 수 있습니다. 입력 시퀀스에 적어도 두 개의 정수가 있다고 가정 할 수 있습니다. (원하는 경우 입력 정수가 다른 것으로 가정 할 수도 있지만 도움이되지 않을 수도 있습니다.) 양수와 음수 (및 0)를 처리 할 수 ​​있어야합니다.

일반적인 코드 골프 스코어링 : 가장 짧은 대답 (바이트)이 이깁니다.

샘플 입력

다음 입력 시퀀스는 각각 Truthy 값을 제공해야합니다.

0 2
-1 1
-100 -200
0 2 6
0 2 6 8
0 2 6 8 12
0 4 6 10 12
-60 0 60 120 180
0 2 6 8 12 26
11 13 17 19 23 29 31
-11 -13 -17 -19 -23 -29 -31

다음 입력 시퀀스는 각각 Falsy 값을 제공해야합니다.

0 1
-1 4
-100 -201
0 2 4
0 2 6 10
0 2 6 8 14
7 11 13 17 19 23 29
-60 0 60 120 180 240 300

팁

• 3 개 이하의 정수 시퀀스는 자동으로 모듈로 4가 허용된다는 점에 유의한다.보다 일반적으로, 길이> k의 시퀀스는 m> k 일 때 자동으로 모듈로 m이다. 허용 가능성을 테스트하기 위해서는 유한 수 m 만 검사하면됩니다.
• 또한 2는 4를 나누고, 허용 가능한 모듈로 2 인 모든 시퀀스 (즉, 모든 짝수 또는 모두 홀수)는 자동으로 허용되는 모듈로 4입니다. 자동적으로 허용되는 모듈로 n. 허용 가능성을 확인하려면 원하는 경우 소수만 고려하면됩니다.
• a1, a2, ..., ak가 허용 가능한 시퀀스이면 a1 + c, a2 + c, ..., ak + c도 정수 c (양수 또는 음수)에 대해서도 허용됩니다.

수학적 관련성 (선택적 판독)

a1, a2, ..., ak를 정수 시퀀스라고하자. n + a1, n + a2, ..., n + ak가 모두 소수가되는 무한정의 정수 n이 있다고 가정하십시오. 그러면 a1, a2, ..., ak가 허용 가능해야한다는 것을 쉽게 알 수 있습니다. 실제로, a1, a2, ..., ak는 허용되지 않으며, m은 a1, a2, ..., ak는 허용 가능한 모듈로 m이 아닌 숫자로하자. 그런 다음 n을 선택하더라도 n + a1, n + a2, ..., n + ak 중 하나는 m의 배수 여야하므로 소수가 될 수 없습니다.

프라임 K 튜플 추측 여전히 수론 벌리고 문제는 본 명세서의 역이다 :는 주장이 A1은 A2는, ..., AK는 허용 시퀀스 (또는 경우 K 튜플 후도) n + a1, n + a2, ..., n + ak가 모두 소수가되도록 무한히 많은 정수 n이어야합니다. 예를 들어, 허용 가능한 시퀀스 0, 2는 n과 n + 2가 모두 소수가되도록 무한히 많은 정수 n이 있어야한다는 진술을 산출합니다. 이것은 쌍둥이 소수 추측입니다 (아직 증명되지 않음).

젤리, 10 바이트

JḊðḶḟ%@ð€Ạ

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 실행하십시오 .

               Input: L.
JḊ             Range of [2..len(L)].
  ð    ð€      For x in [2..len(L)]:
   Ḷ             [0..x-1] (residue classes)
    ḟ              without elements from
     %@            L % x.
         Ạ     All truthy (non-empty)?

Brachylog , 25 24 19 바이트

Karl Napf 덕분에 5 바이트.

lybb '(eM-yA,? : [M] z : % aodA) 
l : 2'(eM-yA,? : [M] z : % aodA)
l : 2 '(eMg :? rz : % adlM)

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

모든 테스트 케이스를 확인하십시오!

l:2'(eMg:?rz:%adlM)
l:2                  Temp = [2:length(input)]
   '(             )  true if the following cannot be proven:
     eM                  M is an element of the interval
                         indicated by Temp, i.e. from 2
                         to the length of input inclusive,
       g:?rz:%adlM       every element of input modulo M
                         de-duplicated has length M.

파이썬, 61 60 바이트

q=lambda l,d=2:d>len(l)or q(l,d+1)&(len({v%d for v in l})<d)

이데온의 모든 테스트 사례

편집 : 논리 및 비트 단위로 대체 및 1 바이트 저장

자바 스크립트 (ES6), 59 바이트

a=>a.every((_,i)=>!i++|new Set(a.map(e=>(e%i+i)%i)).size<i)

@KarlNapf의 나머지 세트 트릭을 사용합니다.

파이썬, 67 64 바이트

명명되지 않은 람다 :

lambda N:all(len({i%m for i in N})<m for m in range(2,len(N)+1))

• EDIT1 : 교체 set()와 함께{}
• Edit2 : 발전기 주위에 대괄호가 필요하지 않습니다. all(...)
• EDIT3 :로 조나단 앨런에 의해 지적 range까지 가야한다len(N)+1

함수로서의 오래된 코드 (96 바이트) :

def f(N):
 for m in range(2,len(N)+1):
    if len(set(i%m for i in N))==m:return False
 return True

수학, 51 바이트

And@@Table[Length@Union@Mod[#,i]<i,{i,2,Length@#}]&

MATL , 11 바이트

"X@QGy\un>v

Truthy는 모든 것을 포함하는 배열 (열 벡터)입니다. Falsy는 하나 이상의 0을 포함하는 배열입니다. 이 링크를 사용하여 이러한 정의를 확인할 수 있습니다 .

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 검증하십시오 : truthy , false (약간 수정 된 코드, 각 경우는 명확성을 위해 수평 벡터를 생성 함).

설명

"       % Take input array. For each; i.e. repeat n times, where n is arrray size
  X@Q   %   Push iteration index plus 1, say k. So k is 2 in the first iteration,
        %   3 in the second, ... n+1 in the last. Actually we only need 2, ..., n;
        %   but the final n+1 doesn't hurt
  G     %   Push input again
  y     %   Duplicate k onto the top of the stack
  \     %   Modulo. Gives vector of remainders of input when divided by k
  un    %   Number of distinct elements
  >     %   True if that number is smaller than k
  v     %   Vertically concatenate with previous results
        % End for each. Implicitly display