Un set di differenze cicliche è un set di numeri interi positivi con una proprietà unica:

1. Lascia che nsia il numero intero più grande nel set.
2. Sia rqualsiasi numero intero (non necessariamente nell'insieme) maggiore di 0 ma minore o uguale a n/2.
3. Sia kil numero di soluzioni per (b - a) % n = rdove ae per bogni membro dell'insieme. Ogni soluzione è una coppia ordinata (a,b). (Si noti inoltre che questa versione di modulo rende positivi i numeri negativi aggiungendovi n, a differenza delle implementazioni in molte lingue.)
4. Infine, se e solo se si tratta di una differenza ciclica impostata, il valore di knon dipende dalla scelta dell'utente r. Cioè, tutti i valori di rdanno lo stesso numero di soluzioni alla congruenza di cui sopra.

Questo può essere illustrato con il seguente esempio:

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)

Ogni valore di rha lo stesso numero di soluzioni, 3 in questo caso, quindi questa è una serie di differenze cicliche.

Ingresso

L'input sarà un elenco di numeri interi positivi. Poiché si tratta di una proprietà set, supponiamo che l'input non sia ordinato. Puoi presumere che nsia almeno 2, sebbene kpossa essere zero.

Produzione

Il tuo programma / funzione dovrebbe generare un valore di verità se l'insieme è un insieme di differenze cicliche, o altrimenti un valore di falso.

Casi test

Set di differenze cicliche validi:

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

( origine dati , sebbene la loro convenzione sia diversa)

Set di differenze cicliche non valide:

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

Gelatina , 14 7 byte

_þ%ṀṬSE

Provalo online!

Come funziona

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

Buccia , 13 byte

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

Provalo online!

I tre apici 1 sembrano dispendiosi ...

Spiegazione

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

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

Provalo online!

Nota, non abbiamo bisogno di dividere l'elemento massimo per due a causa della simmetria (possiamo controllare i conteggi di tutti i moduli 1su max(input) - 1).

Spiegazione

#~Permutations~{2}

Prendi tutte le permutazioni di lunghezza 2 dell'input.

#-#2&@@@

Trova le differenze di ciascuno

Mod[ ... ,Max@#]

Mod il risultato dall'elemento massimo dell'input.

Counts@

Trova le frequenze di ciascun elemento.

SameQ@@

Restituisce se tutti i numeri sono uguali.

Python 3 , 86 84 81 byte

^{-3 byte grazie 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

Provalo online!

JavaScript (ES6), 87 byte

Restituisce 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])

Casi 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 byte

Include +2perap

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 byte

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

Provalo online!

Rubino , 81 byte

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

Provalo online!

Ungolfed:

->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 byte

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]

È la funzione che esegue il controllo. Calcola solo tutte le differenze e conta.