Un ensemble de différences cycliques est un ensemble d'entiers positifs avec une propriété unique:

1. Soit nle plus grand entier de l'ensemble.
2. Soit rn'importe quel entier (pas nécessairement dans l'ensemble) supérieur à 0 mais inférieur ou égal à n/2.
3. Laissez - kle nombre de solutions à (b - a) % n = roù aet bsont des membres de l'ensemble. Chaque solution est une paire ordonnée (a,b). (Notez également que cette version de modulo rend les nombres négatifs positifs en y ajoutant n, contrairement aux implémentations dans de nombreuses langues.)
4. Enfin, si et seulement s'il s'agit d'un ensemble de différences cycliques, la valeur de kne dépend pas de votre choix de r. Autrement dit, toutes les valeurs de rdonnent le même nombre de solutions à la congruence ci-dessus.

Cela peut être illustré par l'exemple suivant:

Cyclic difference set: {4,5,6,8,9,11}
0 < r <= 11/2, so r = 1,2,3,4,5
r=1: (4,5) (5,6) (8,9)
r=2: (4,6) (6,8) (9,11)
r=3: (5,8) (6,9) (8,11)
r=4: (4,8) (5,9) (11,4)  since (4-11)%11=(-7)%11=4
r=5: (4,9) (6,11) (11,5)

Chaque valeur de ra le même nombre de solutions, 3 dans ce cas, il s'agit donc d'un ensemble de différences cycliques.

Contribution

L'entrée sera une liste d'entiers positifs. Puisqu'il s'agit d'une propriété set, supposez que l'entrée n'est pas triée. Vous pouvez supposer que nc'est au moins 2, mais kpeut être nul.

Production

Votre programme / fonction doit sortir une valeur véridique si l'ensemble est un ensemble de différence cyclique, ou une valeur de falsey sinon.

Cas de test

Ensembles de différences cycliques valides:

10,12,17,18,21
7,5,4
57,1,5,7,17,35,38,49
1,24,35,38,40,53,86,108,114,118,135,144,185,210,254,266,273
16,3,19,4,8,10,15,5,6
8,23,11,12,15,2,3,5,7,17,1

( source de données , bien que leur convention soit différente)

Ensembles de différences cycliques non valides:

1,2,3,4,20
57,3,5,7,17,35,38,49
3,4,5,9
14,10,8

Gelée , 14 7 octets

_þ%ṀṬSE

Essayez-le en ligne!

Comment ça fonctionne

_þ%ṀṬSE  Main link. Argument: A (array of unique elements / ordered set)

_þ       Subtract table; yield a 2D array of all possible differences of two
         (not necessarily distinct) elements of A.
  %Ṁ     Take the differences modulo max(A).
    Ṭ    Untruth; map each array of differences modulo max(A) to a Boolean array
         with 1's at the specified indices. Note that all 0's in the index array
         are ignored, since indexing is 1-based in Jelly.
     S   Take the sum of these arrays, counting occurrences.
      E  Test if all resulting counts are equal.

Husk , 13 octets

Ë#m%▲¹×-¹¹ḣ½▲

Essayez-le en ligne!

Les trois exposants 1 semblent inutiles ...

Explication

Ë#m%▲¹×-¹¹ḣ½▲  Input is a list, say x=[7,5,4]
            ▲  Maximum: 7
           ½   Halve: 3.5
          ḣ    Inclusive range from 1: [1,2,3]
Ë              All elements are equal under this function:
                Argument is a number, say n=2.
      ×-¹¹      Differences of all pairs from x: [0,-2,2,-3,0,3,-1,1,0]
  m%▲¹          Map modulo max(x): [0,5,2,4,0,3,6,1,0]
 #              Count occurrences of n: 1

Wolfram Language (Mathematica) , 53 52 octets

SameQ@@Counts@Mod[#-#2&@@@#~Permutations~{2},Max@#]&

Essayez-le en ligne!

Remarque, on n'a pas besoin de diviser l'élément max par deux en raison de symétrie (on peut vérifier tous les comptes de modulos 1à max(input) - 1).

Explication

#~Permutations~{2}

Prenez toutes les permutations de longueur 2 de l'entrée.

#-#2&@@@

Trouvez les différences de chacun

Mod[ ... ,Max@#]

Modifiez le résultat par l'élément maximal de l'entrée.

Counts@

Trouvez les fréquences de chaque élément.

SameQ@@

Indiquez si tous les nombres sont identiques.

Python 3 , 86 84 81 octets

^{-3 octets à JungHwan Min}

lambda x:len({*map([(b-a)%max(x)for a in x for b in x].count,range(1,max(x)))})<2

Essayez-le en ligne!

JavaScript (ES6), 87 octets

Renvoie 0 ou 1 .

a=>a.map(b=>a.map(c=>x[c=(c-b+(n=Math.max(...a)))%n-1]=-~x[c]),x=[])|!x.some(v=>v^x[0])

Cas de test

let f =

a=>a.map(b=>a.map(c=>x[c=(c-b+(n=Math.max(...a)))%n-1]=-~x[c]),x=[])|!x.some(v=>v^x[0])

console.log('[Truthy]')
console.log(f([10,12,17,18,21]))
console.log(f([7,5,4]))
console.log(f([57,1,5,7,17,35,38,49]))
console.log(f([1,24,35,38,40,53,86,108,114,118,135,144,185,210,254,266,273]))
console.log(f([16,3,19,4,8,10,15,5,6]))
console.log(f([8,23,11,12,15,2,3,5,7,17,1]))

console.log('[Falsy]')
console.log(f([1,2,3,4,20]))
console.log(f([57,3,5,7,17,35,38,49]))
console.log(f([3,4,5,9]))
console.log(f([14,10,8]))

Perl, 68 67 66 octets

Comprend +2pourap

perl -apE '\@G[@F];pop@G;s:\d+:$G[$_-$&].=1for@F:eg;$_="@G"=~/^1*( 1*)\1*$/' <<< "4 5 6 8 9 11"

Python 3 , 74 octets

lambda x:len({sum(1+(a+r)%max(x)in x for a in x)for r in range(max(x))})<3

Essayez-le en ligne!

Rubis , 81 octets

->s{n=s.max
(1..n/2).map{|r|s.permutation(2).count{|a,b|(b-a)%n==r}}.uniq.size<2}

Essayez-le en ligne!

Non golfé:

->s{
  n=s.max
  (1..n/2).map{|r|               # For each choice of r
    s.permutation(2).count{|a,b| # Count the element pairs
      (b-a)%n==r                 #   for which this equality holds
    }
  }.uniq.size<2                  # All counts should be identical.
}

Haskell, 84 octets

l s=all((g 1==).g)[1..t-1]where t=maximum s;g j=[1|x<-s>>=(`map`s).(-),x==j||x+t==j]

l est la fonction qui effectue la vérification. Il calcule simplement toutes les différences et compte.