introduzione

Supponiamo che io abbia un elenco di numeri interi, diciamo L = [-1,2,2,1,2,7,1,4] . Mi piace avere l'equilibrio nella mia vita, quindi sono felice di vedere che ha tanti elementi dispari quanti elementi pari. Inoltre, ha anche un numero uguale di elementi in tutte le classi modulo di 3 in cui ha elementi in:

         [-1,2,2,1,2,7,1,4]
0 mod 3:
1 mod 3:         1   7 1 4
2 mod 3:  -1 2 2   2

Purtroppo, per le classi modulo di 4 questo non vale più. In generale, diciamo che un elenco non vuoto è bilanciato modulo N se ha un numero uguale di elementi in tutte le classi modulo di N per cui questo numero non è 0. L'elenco L sopra è bilanciato modulo 2 e 3, ma modulo sbilanciato 4.

L'obiettivo

Il tuo input è un elenco non vuoto L di numeri interi presi in qualsiasi formato ragionevole. Il tuo output è l'elenco di quegli interi N ≥ 2 tali che L è bilanciato modulo N , sempre in qualsiasi formato ragionevole. L'ordine dell'output non ha importanza, ma non deve contenere duplicati.

È garantito che ci sono solo molti numeri nell'output, il che significa precisamente che non tutti gli elementi di L si verificano un numero uguale di volte in esso. Esempi di input non validi sono [3] , [1,2] e [0,4,4,0,3,3] . Si noti che il numero più grande nell'output è al massimo max (L) - min (L) .

Vince il conteggio dei byte più basso in ogni lingua e si applicano le regole standard per il golf del codice .

Casi test

[1,1,2] -> []
[1,1,5] -> [2,4]
[1,1,24] -> [23]
[1,2,3,2] -> [2]
[12,12,-4,20] -> [2,3,4,6,8,12,24]
[1,1,12,12,-3,7] -> [3,10]
[-1,2,2,1,2,7,1,4] -> [2,3]
[4,-17,-14,-18,-18,3,5,8] -> []
[-18,0,-6,20,-13,-13,-19,13] -> [2,4,19]
[-11,-19,-19,3,10,-17,13,7,-5,16,-20,20] -> []
[3,0,1,5,3,-6,-16,-20,10,-6,-11,11] -> [2,4]
[-18,-20,14,13,12,-3,14,6,7,-19,17,19] -> [2,3]
[-16,-9,6,13,0,-17,-5,1,-12,-4,-16,-4] -> [3,9]
[-97,-144,3,53,73,23,37,81,-104,41,-125,70,0,111,-88,-2,25,-112,54,-76,136,-39,-138,22,56,-137,-40,41,-141,-126] -> [2,3,6]

05AB1E , 11 byte

ÄOL¦ʒ%{γ€gË

Provalo online!

ÄOL¦ʒ%{γ€gË  | Full program.

Ä            | Absolute value (element-wise).
 O           | Sum.
  L          | 1-based inclusive range.
   ¦         | Remove the first element (generates the range [2 ... ^^]).
    ʒ        | Filter / Select.
     %       | Modulo of the input with the current integer (element-wise).
      {      | Sort.
       γ     | Group into runs of adjacent elements.
        €g   | Get the length of each.
          Ë  | Are all equal?

Wolfram Language (Mathematica) , 56 52 byte

Grazie a Non un albero per il salvataggio di 4 byte.

Cases[Range[2,#.#],n_/;Equal@@Last/@Tally[#~Mod~n]]&

Provalo online!

Il trucco principale del golf è usare la somma dei valori assoluti (o la 1-norma) somma dei valori al quadrato, calcolata come prodotto punto con se stessa, come limite superiore anziché Max@#-Min@#. Altrimenti, implementa le specifiche in modo molto letterale.

Perl 6 ,  52  48 byte

{grep {[==] .classify(*X%$^a).values},2.. .max-.min}

Provalo

{grep {[==] bag($_ X%$^a).values},2.. .max-.min}

Provalo

Allargato:

{  # bare block lambda with implicit parameter ｢$_｣

  grep

    {  # bare block lambda with placeholder parameter ｢$a｣

      [==]           # reduce with &infix:«==» (are the counts equal to each other)

        bag(         # group moduluses together

          $_ X% $^a  # find all the moduluses using the current divisor ｢$a｣

        ).values     # the count of each of the moduluses
    },

    2 .. .max - .min # all possible divisors
}

Haskell , 85 84 byte

f l=[n|n<-[2..sum$abs<$>l],all.(==)=<<head$[r|m<-[0..n],_:r<-[[0|x<-l,mod x n==m]]]]

Provalo online! Utilizza la somma dei valori assoluti al massimo dalla risposta di Martin Ender .

Modifica: -1 byte grazie a Ørjan Johansen.

Spiegazione:

f l=                             -- Given a list of numbers l,
  [n|n<-                       ] -- return a list of all numbers n of the range
    [2..sum$abs<$>l],            -- from 2 to the sum of the absolute values of l
      all.(==)=<<head$           -- for which all elements of the following list are equal:
        [r|m<-[0..n],         ]  -- A list r for each number m from 0 to n, where
          _:r<-[             ]   -- r is the tail of a list (to filter out empty lists)
          [0|x<-l,mod x n==m]    -- of as many zeros as elements of l mod n equal m.

Buccia , 13 byte

f₅⁰…2ṁa⁰
Λ≈k%

Provalo online!

R , 75 72 byte

function(L){for(x in 2:(max(L)-min(L)))F=c(F,!sd(table(L%%x)))
which(F)}

Provalo online!

Utilizza tableper calcolare i conteggi di ciascun modulo intero x. La deviazione standard sddi un insieme di numeri è zero se sono tutti uguali e positivi in ​​caso contrario. Quindi !sd(table(L%%x))è TRUEovunque Lmod mod bilanciato xe falso altrimenti. Questi valori vengono quindi concatenati F.

whichquindi restituisce gli indici dei valori reali dalla funzione. Poiché R utilizza l'indicizzazione basata su 1 ed Fè inizialmente un vettore di lunghezza uno con valore FALSE, questo restituirà correttamente i valori che iniziano con2 .

Ci si potrebbe aspettare che la funzione integrata rangecalcoli l' intervallo di un set di dati , cioè max(D)-min(D), ma purtroppo calcola e restituisce il vettore c(min(D), max(D)).

Pulito , 121 byte

Usa il trucco della somma degli assoluti dalla risposta di Martin Ender.

golfed:

import StdEnv   
f l=[n\\n<-[2..sum(map abs l)]|length(removeDup[length[m\\m<-[(e rem n+n)rem n\\e<-l]|m==c]\\c<-[0..n]])<3]

Leggibile:

import StdEnv
maximum_modulus l = sum (map abs l)
// mod, then add the base, then mod again (to fix issues with negative numbers)
list_modulus l n = [((el rem n) + n) rem n \\ el <- l]
// count the number of elements with each mod equivalency
equiv_class_count l n = [length [m \\ m <- list_modulus l n | m == c] \\ c <- [0..n]]
// for every modulus, take where there are only two quantities of mod class members
f l=[n \\ n <- [2..maximum_modulus l] | length (removeDup (equiv_class_count l n)) < 3]

Provalo online!

Gelatina , 12 byte

⁹%LƙE
ASḊçÐf

Provalo online!

Grazie a user202729 per il salvataggio di un byte e a Martin Ender (indirettamente) per il salvataggio di un byte.

Come funziona

⁹%LƙE ~ Helper link. Let's call the argument N.

⁹%    ~ Modulo the input by N (element-wise).
  Lƙ  ~ Map with length over groups formed by consecutive elements.
    E ~ All equal?

ASḊçÐf ~ Main link.

AS     ~ Absolute value of each, sum.
  Ḋ    ~ Dequeue (create the range [2 ... ^]).
   çÐf ~ Filter by the last link called dyadically.

Un'alternativa di una riga 12-byte può essere provata online!

Python 3, 120 102 byte

Non abbastanza da golf.

-18 byte grazie a Mr. Xcoder .

f=lambda a,i=2:[]if i>max(a)-min(a)else(len({*map([k%i for k in a].count,range(i)),0})<3)*[i]+f(a,i+1)

Provalo online!

MATL , 19 byte

-4 byte grazie a Luis Mendo!

S5L)d:Q"G@\8#uZs~?@

Provalo online!

Porto di mia risposta in R .

Suppose we have input [12,12,-4,20]
         # (implicit input), stack: [12,12,-4,20]
S        # sort the list, stack: [-4, 12, 12, 20]
5L       # push [1 0], stack: [[-4, 12, 12, 20]; [1 0]]
)        # 1-based modular index, stack: [-4, 20]
d        # successive differences, stack: [24]
:        # generate 1:(max(data)-min(data)), stack: [[1...24]]
Q        # increment to start at 2, stack: [[2...25]]
"        # for each element in [2...25]
 G       # push input, stack: [[12,12,-4,20]]
 @       # push loop index, stack: [[12,12,-4,20], 2]
 \       # compute modulo, stack: [[0,0,0,0]]
 8#      # use alternate output spec, unique has 4 outputs, so 8 keeps only the 4th
 u       # unique. 4th output is the counts of each unique value, stack: [4]
 Zs      # compute standard deviation, stack: [0]
 ~       # logical negate, stack: [T]
 ?       # if true,
  @      # push loop index
         # (implicit end of if)
         # (implicit end of for loop)
         # (implicit output of stack as column vector

JavaScript (ES6), 117 byte

Emette un elenco di valori separati da spazi.

a=>(g=m=>a.map(n=>x[k=(z|=m/2<n|m/2<-n,n%m+m)%m]=-~x[k],y=z=0,x=[])|z?(x.some(x=>x-(y?y:y=x))?'':m+' ')+g(m+1):'')(2)

Casi test

let f =

a=>(g=m=>a.map(n=>x[k=(z|=m/2<n|m/2<-n,n%m+m)%m]=-~x[k],y=z=0,x=[])|z?(x.some(x=>x-(y?y:y=x))?'':m+' ')+g(m+1):'')(2)

console.log(f([1,1,2])) // []
console.log(f([1,1,5])) // [2,4]
console.log(f([1,1,24])) // [23]
console.log(f([1,2,3,2])) // [2]
console.log(f([12,12,-4,20])) // [2,3,4,6,8,12,24]
console.log(f([1,1,12,12,-3,7])) // [3,10]
console.log(f([-1,2,2,1,2,7,1,4])) // [2,3]
console.log(f([4,-17,-14,-18,-18,3,5,8])) // []
console.log(f([-18,0,-6,20,-13,-13,-19,13])) // [2,4,19]
console.log(f([-11,-19,-19,3,10,-17,13,7,-5,16,-20,20])) // []
console.log(f([3,0,1,5,3,-6,-16,-20,10,-6,-11,11])) // [2,4]
console.log(f([-18,-20,14,13,12,-3,14,6,7,-19,17,19])) // [2,3]
console.log(f([-16,-9,6,13,0,-17,-5,1,-12,-4,-16,-4])) // [3,9]
console.log(f([-97,-144,3,53,73,23,37,81,-104,41,-125,70,0,111,-88,-2,25,-112,54,-76,136,-39,-138,22,56,-137,-40,41,-141,-126])) // [2,3,6]

Clojure, 91 byte

#(for[i(range 2(apply +(map * % %))):when(apply =(vals(frequencies(for[j %](mod j i)))))]i)

L'uso frequenciesnon è ideale nel golf di codice.

J, 38 byte

[:}.@I.([:i.1#.|)(1=1#.[:~:|#/.])"0 1]

Il merito va al signor Xcoder per la somma dei trucchi dei valori assoluti.

Se lo desideri, modifica in un collegamento TIO: ho giocato a golf un po 'di fretta.

Spiegazione e collegamento TIO in arrivo (ish).

APL (Dyalog) , 43 41 38 30 byte

Il simbolo nel codice racconta l'intera storia.

8 byte salvati grazie a @ Adám

∊x⊆⍨1=⊂(≢∘∪1⊥|∘.=|)¨⍨x←1+∘⍳1⊥|

Provalo online!