Un conjunto de diferencias cíclicas es un conjunto de enteros positivos con una propiedad única:

1. Deje nser el número entero más grande del conjunto.
2. Sea rcualquier número entero (no necesariamente en el conjunto) mayor que 0 pero menor o igual que n/2.
3. Deje kser el número de soluciones para (b - a) % n = rdónde ay bson miembros del conjunto. Cada solución es un par ordenado (a,b). (También tenga en cuenta que esta versión del módulo hace que los números negativos sean positivos al agregarle n, a diferencia de las implementaciones en muchos idiomas).
4. Finalmente, si y solo si este es un conjunto de diferencias cíclicas, el valor de kno depende de su elección r. Es decir, todos los valores de rdan el mismo número de soluciones a la congruencia anterior.

Esto se puede ilustrar con el siguiente ejemplo:

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)

Cada valor de rtiene el mismo número de soluciones, 3 en este caso, por lo que este es un conjunto de diferencias cíclicas.

Entrada

La entrada será una lista de enteros positivos. Como se trata de una propiedad establecida, suponga que la entrada no está ordenada. Puede suponer que nes al menos 2, aunque kpuede ser cero.

Salida

Su programa / función debería generar un valor verdadero si el conjunto es un conjunto de diferencia cíclica, o un valor falso de lo contrario.

Casos de prueba

Conjuntos de diferencia cíclica válidos:

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

( fuente de datos , aunque su convención es diferente)

Conjuntos de diferencia cíclica no válidos:

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

Jalea , 14 7 bytes

_þ%ṀṬSE

Pruébalo en línea!

Cómo funciona

_þ%ṀṬ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.

Casco , 13 bytes

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

Pruébalo en línea!

Los tres superíndices 1 parecen un desperdicio ...

Explicación

Ë#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 bytes

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

Pruébalo en línea!

Tenga en cuenta, que no es necesario dividir el elemento máximo por dos debido a la simetría (podemos hacer un recuento de todos los modulos 1a max(input) - 1).

Explicación

#~Permutations~{2}

Tome todas las permutaciones de longitud 2 de la entrada.

#-#2&@@@

Encuentra las diferencias de cada

Mod[ ... ,Max@#]

Modifique el resultado por el elemento máximo de la entrada.

Counts@

Encuentra las frecuencias de cada elemento.

SameQ@@

Devuelve si todos los números son iguales.

Pitón 3 , 86 84 81 bytes

^{-3 bytes gracias a JungHwan Min}

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

Pruébalo en línea!

JavaScript (ES6), 87 bytes

Devuelve 0 o 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])

Casos de prueba

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 bytes

Incluye +2paraap

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 bytes

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

Pruébalo en línea!

Ruby , 81 bytes

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

Pruébalo en línea!

Sin 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 bytes

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 es la función que hace la verificación. Simplemente calcula todas las diferencias y cuenta.