Introdução

Suponha que eu tenha uma lista de números inteiros, digamos L = [-1,2,2,1,2,7,1,4] . Eu gosto de ter equilíbrio na minha vida, então estou feliz em ver que tem tantos elementos estranhos quanto pares. Além disso, ele também possui um número igual de elementos em todas as classes de módulo de 3 e possui elementos em:

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

Infelizmente, para as classes de módulo 4, isso não se aplica mais. Em geral, dizemos que uma lista não vazia é o módulo N balanceado se tiver um número igual de elementos em todas as classes de módulo de N para as quais esse número não é 0. A lista L acima é o módulo balanceado 2 e 3, mas o módulo desbalanceado 4)

A tarefa

Sua entrada é uma lista não vazia L de números inteiros, obtidos em qualquer formato razoável. Sua saída é a lista desses números inteiros N ≥ 2, de modo que L é um módulo N balanceado , novamente em qualquer formato razoável. A ordem da saída não importa, mas não deve conter duplicatas.

É garantido que haja apenas muitos números finitos na saída, o que significa precisamente que nem todos os elementos de L ocorrem um número igual de vezes nela. Exemplos de entradas inválidas são [3] , [1,2] e [0,4,4,0,3,3] . Observe que o maior número na saída é no máximo max (L) - min (L) .

A contagem de bytes mais baixa em cada idioma vence e aplicam -se regras padrão de código de golfe .

Casos de teste

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

ÄOL¦ʒ%{γ€gË

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

Obrigado a Não é uma árvore por salvar 4 bytes.

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

Experimente online!

O principal truque do golfe é usar a soma dos valores absolutos (ou a norma 1) dos valores ao quadrado, computados como um produto escalar consigo, como o limite superior em vez de Max@#-Min@#. Caso contrário, apenas implementa as especificações literalmente.

Perl 6 ,  52  48 bytes

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

Teste-o

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

Teste-o

Expandido:

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

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

Experimente online! Usa a soma dos valores absolutos como máximo da resposta de Martin Ender .

Edit: -1 byte graças a Ørjan Johansen.

Explicação:

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.

Casca , 13 bytes

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

Experimente online!

R , 75 72 bytes

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

Experimente online!

Usa tablepara calcular as contagens de cada módulo inteiro x. O desvio padrão sdde um conjunto de números é zero se todos forem iguais e positivos caso contrário. Daí !sd(table(L%%x))é TRUEonde quer que Lseja mod mod equilibrado xe falso caso contrário. Esses valores são concatenados em F.

whichem seguida, retorna os índices de valores verdadeiros da função Como R usa indexação baseada em 1 e Fé inicialmente um vetor de comprimento um com valor FALSE, isso retornará corretamente valores começando com 2.

Pode-se esperar que a função interna rangecalcule o intervalo de um conjunto de dados , ou seja max(D)-min(D), mas, infelizmente, calcula e retorna o vetor c(min(D), max(D)).

Limpo , 121 bytes

Usa o truque da soma dos absolutos da resposta de Martin Ender.

Golfe:

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]

Legível:

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]

Experimente online!

Gelatina , 12 bytes

⁹%LƙE
ASḊçÐf

Experimente online!

Agradecemos a user202729 por salvar um byte e a Martin Ender (indiretamente) por salvar um byte.

Como funciona

⁹%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.

Uma alternativa de uma linha de 12 bytes pode ser experimentada online!

Python 3, 120 102 bytes

Não é muito golfista.

-18 bytes graças ao Sr. 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)

Experimente online!

MATL , 19 bytes

-4 bytes graças a Luis Mendo!

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

Experimente online!

Porto de minha resposta em 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 bytes

Produz uma lista de valores separados por espaço.

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)

Casos de teste

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 bytes

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

O uso frequenciesnão é ideal no código de golfe.

J, 38 bytes

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

O crédito é para o Sr. Xcoder pela soma dos truques de valores absolutos.

Edite em um link TIO, se quiser - joguei isso com pressa.

Explicação e link TIO em breve (ish).

APL (Dyalog) , 43 41 38 30 bytes

Os ⍨s no código contam a história toda.

8 bytes salvos graças a @ Adám

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

Experimente online!