Résumé: testez si une séquence d'entrée d'entiers est "admissible", ce qui signifie qu'elle ne couvre pas toutes les classes de résidus pour n'importe quel module.

Qu'est-ce qu'une séquence "admissible"?

Etant donné un entier m ≥ 2, les classes de résidus modulo m ne sont que les m progressions arithmétiques possibles de différence commune m. Par exemple, lorsque m = 4, les 4 classes de résidus modulo 4 sont

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

La kième classe de résidus comprend tous les entiers dont le reste lors de la division par m est égal à k. (tant que l'on définit correctement "reste" pour les entiers négatifs)

Une séquence d'entiers a1, a2, ..., ak est admissible modulo m si elle ne coupe pas au moins une des classes de résidus. Par exemple, {0, 1, 2, 3} et {-4, 5, 14, 23} ne sont pas admissibles modulo 4, mais {0, 1, 2, 4} et {0, 1, 5, 9} et {0, 1, 2, -3} sont modulo 4. admissibles. De plus, {0, 1, 2, 3, 4} n'est pas modulo 4 admissible, tandis que {0, 1, 2} est modulo 4 admissible.

Enfin, une séquence d'entiers est simplement admissible si elle est admissible modulo m pour chaque entier m ≥ 2.

Le défi

Écrivez un programme ou une fonction qui prend en entrée une séquence d'entiers et renvoie une valeur Truthy (cohérente) si la séquence est admissible et une valeur Falsy (cohérente) si la séquence n'est pas admissible.

La séquence d'entrée d'entiers peut être dans n'importe quel format raisonnable. Vous pouvez supposer que la séquence d'entrée a au moins deux entiers. (Vous pouvez également supposer que les entiers d'entrée sont distincts si vous le souhaitez, mais cela n'aide probablement pas.) Vous devez être capable de gérer des entiers positifs et négatifs (et 0).

Score de code-golf habituel : la réponse la plus courte, en octets, l'emporte.

Exemple d'entrée

Les séquences d'entrée suivantes doivent chacune donner une valeur 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

Les séquences d'entrée suivantes doivent chacune donner une valeur 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

Conseils

• Notez que toute séquence de 3 entiers ou moins est automatiquement modulo 4. Plus généralement, une séquence de longueur k est automatiquement modulo m lorsque m> k. Il s'ensuit que le test d'admissibilité ne nécessite vraiment que la vérification d'un nombre fini de m.
• Notez également que 2 divise 4, et que toute séquence qui est admissible modulo 2 (c'est-à-dire, tout pair ou tout impair) est automatiquement admissible modulo 4. Plus généralement, si m divise n et qu'une séquence est admissible modulo m, alors elle est automatiquement modulo n. Pour vérifier la recevabilité, il suffit donc de ne considérer que prime m si vous le souhaitez.
• Si a1, a2, ..., ak est une séquence admissible, alors a1 + c, a2 + c, ..., ak + c est également admissible pour tout entier c (positif ou négatif).

Pertinence mathématique (lecture facultative)

Soit a1, a2, ..., ak une suite d'entiers. Supposons qu'il existe une infinité de nombres entiers n tels que n + a1, n + a2, ..., n + ak sont tous premiers. Il est alors facile de montrer que a1, a2, ..., ak doivent être admissibles. En effet, supposons que a1, a2, ..., ak ne soit pas admissible, et soit m un nombre tel que a1, a2, ..., ak ne soit pas admissible modulo m. Alors, peu importe ce que nous choisissons, l'un des nombres n + a1, n + a2, ..., n + ak doit être un multiple de m, il ne peut donc pas être premier.

La conjecture des k-tuples premiers est l'inverse de cette affirmation, qui reste un problème largement ouvert dans la théorie des nombres: elle affirme que si a1, a2, ..., ak est une séquence admissible (ou k-tuple ), alors là doit être une infinité de nombres entiers n tels que n + a1, n + a2, ..., n + ak sont tous premiers. Par exemple, la séquence admissible 0, 2 donne l'énoncé qu'il devrait y avoir une infinité de nombres entiers n tels que n et n + 2 sont premiers, c'est la conjecture des nombres premiers jumeaux (toujours non prouvée).

Gelée, 10 octets

JḊðḶḟ%@ð€Ạ

Essayez-le en ligne! ou exécutez tous les cas de test .

               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 octets

5 octets grâce à Karl Napf.

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

Essayez-le en ligne!

Vérifiez tous les cas de test!

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.

Python, 61 60 octets

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

Tous les cas de test sur ideone

Modifier: remplacé logique et au niveau du bit & pour enregistrer un octet

JavaScript (ES6), 59 octets

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

Utilise le jeu de restes de @ KarlNapf.

Python, 67 64 octets

En tant que lambda sans nom:

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

• Edit1: remplacé set()par{}
• Edit2: pas besoin de crochets autour du générateur dans all(...)
• Edit3: Comme l'a souligné Jonathan Allan, rangedoit aller jusqu'àlen(N)+1

Ancien code comme fonction (96 octets):

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 octets

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

MATL , 11 octets

"X@QGy\un>v

Truthy est un tableau (vecteur de colonne) contenant tous les uns. Falsy est un tableau contenant au moins un zéro. Vous pouvez vérifier ces définitions en utilisant ce lien .

Essayez-le en ligne! Ou vérifiez tous les cas de test: véridiques , fausses (code légèrement modifié, chaque cas produit un vecteur horizontal pour plus de clarté).

Explication

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