Resumo executivo: teste se uma sequência de entrada de números inteiros é "admissível", o que significa que ela não cobre todas as classes de resíduos para qualquer módulo.

O que é uma sequência "admissível"?

Dado um número inteiro m ≥ 2, as classes de resíduos módulo m são apenas as m progressões aritméticas possíveis da diferença comum m. Por exemplo, quando m = 4, as 4 classes de resíduos módulo 4 são

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

A k-ésima classe de resíduo consiste em todos os números inteiros cujo restante ao dividir por m é igual a k. (desde que se defina "restante" corretamente para números inteiros negativos)

Uma sequência de números inteiros a1, a2, ..., ak é admissível no módulo m se não cruzar pelo menos uma das classes de resíduos. Por exemplo, {0, 1, 2, 3} e {-4, 5, 14, 23} não são o módulo 4 admissível, mas {0, 1, 2, 4} e {0, 1, 5, 9} e {0, 1, 2, -3} são o módulo admissível 4. Além disso, {0, 1, 2, 3, 4} não é o módulo admissível 4, enquanto {0, 1, 2} é o módulo admissível 4.

Finalmente, uma sequência de números inteiros é simplesmente admissível se for o módulo m admissível para cada número inteiro m ≥ 2.

O desafio

Escreva um programa ou função que use uma sequência de números inteiros como entrada e retorne um valor Truthy (consistente) se a sequência for admissível e um valor Falsy (consistente) se a sequência não for admissível.

A sequência de entrada de números inteiros pode estar em qualquer formato razoável. Você pode assumir que a sequência de entrada possui pelo menos dois números inteiros. (Você também pode assumir que os números inteiros de entrada são distintos, se desejar, embora provavelmente não ajude.) Você deve poder manipular números inteiros positivos e negativos (e 0).

Pontuação usual de código-golfe : a resposta mais curta, em bytes, vence.

Entrada de amostra

As seguintes seqüências de entrada devem fornecer um valor 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

As seguintes seqüências de entrada devem fornecer um valor de falsidade:

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

Dicas

• Observe que qualquer sequência de 3 ou menos números inteiros é automaticamente módulo admissível 4. Mais geralmente, uma sequência de comprimento k é automaticamente módulo admissível m quando m> k. Conclui-se que o teste de admissibilidade realmente requer apenas a verificação de um número finito de m.
• Observe também que 2 divide 4 e que qualquer sequência admissível no módulo 2 (ou seja, todos os pares ou ímpares) é automaticamente admissível no módulo 4. Mais geralmente, se m divide n e uma sequência é admissível no módulo m, então é módulo automaticamente admissível n. Para verificar a admissibilidade, basta considerar apenas o primeiro m, se desejar.
• Se a1, a2, ..., ak é uma sequência admissível, então a1 + c, a2 + c, ..., ak + c também é admissível para qualquer número inteiro c (positivo ou negativo).

Relevância matemática (leitura opcional)

Seja a1, a2, ..., ak uma sequência de números inteiros. Suponha que existam infinitos numeros inteiros n tais que n + a1, n + a2, ..., n + ak sejam primos. Então é fácil mostrar que a1, a2, ..., ak deve ser admissível. De fato, suponha que a1, a2, ..., ak não seja admissível e seja m um número tal que a1, a2, ..., ak não seja admissível módulo m. Então, não importa o que n escolhemos, um dos números n + a1, n + a2, ..., n + ak deve ser um múltiplo de m, portanto, não pode ser primo.

A conjectura das k-tuplas primárias é o inverso dessa afirmação, que ainda é um problema amplamente aberto na teoria dos números: afirma que se a1, a2, ..., ak é uma sequência admissível (ou k-tupla ), então existe deve haver infinitos números inteiros n de modo que n + a1, n + a2, ..., n + ak sejam primos. Por exemplo, a sequência admissível 0, 2 produz a afirmação de que deve haver infinitos números inteiros n de modo que n e n + 2 sejam primos, essa é a conjectura de primos gêmeos (ainda não comprovada).

Gelatina, 10 bytes

JḊðḶḟ%@ð€Ạ

Experimente online! ou execute todos os casos de teste .

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

Braquilog , 25 24 19 bytes

5 bytes graças a Karl Napf.

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

Experimente online!

Verifique todos os casos de teste!

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.

Pitão, 61 60 bytes

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

Todos os casos de teste em ideone

Editar: substituído lógico e com bit a bit & para salvar um byte

JavaScript (ES6), 59 bytes

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

Usa o truque Conjunto de Restos de @ KarlNapf.

Python, 67 64 bytes

Como lambda sem nome:

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

• Edit1: substituído set()por{}
• Edit2: não precisa de colchetes ao redor do gerador all(...)
• Edit3: Como apontado por Jonathan Allan, rangedeve ir atélen(N)+1

Código antigo como função (96 bytes):

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

Mathematica, 51 bytes

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

MATL , 11 bytes

"X@QGy\un>v

Truthy é uma matriz (vetor de coluna) que contém todos. Falsy é uma matriz que contém pelo menos um zero. Você pode verificar essas definições usando este link .

Experimente online! Ou verificar todos os casos de teste: truthy , Falsas (código ligeiramente modificada, cada caso produz um vetor horizontal para maior clareza).

Explicação

"       % 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