Wprowadzenie

Załóżmy, że mam listę liczb całkowitych, powiedzmy L = [-1,2,2,1,2,7,7,1,4] . Lubię w życiu zachować równowagę, więc cieszę się, że ma tyle nieparzystych elementów, co parzystych. Co więcej, ma również taką samą liczbę elementów we wszystkich klasach modulo 3, w których ma elementy:

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

Niestety w przypadku klas modulo 4 to już nie obowiązuje. Mówimy ogólnie, że niepusta lista jest zrównoważona modulo N, jeśli ma taką samą liczbę elementów we wszystkich klasach modulo N, dla których ta liczba nie jest równa 0. Powyższa lista L jest zrównoważona modulo 2 i 3, ale niezrównoważona modulo 4

Zadanie

Twoje dane wejściowe to niepusta lista L liczb całkowitych pobrana w dowolnym rozsądnym formacie. Twoje wyjście to lista liczb całkowitych N ≥ 2, tak że L jest zbalansowanym modułem N , ponownie w dowolnym rozsądnym formacie. Kolejność danych wyjściowych nie ma znaczenia, ale nie powinna zawierać duplikatów.

Gwarantuje się, że na wyjściu jest tylko skończenie wiele liczb, co oznacza dokładnie, że nie wszystkie elementy L występują w nim tyle samo razy. Przykładami nieprawidłowych danych wejściowych są [3] , [1,2] i [0,4,4,0,3,3] . Zauważ, że największa liczba na wyjściu wynosi co najwyżej maks. (L) - min (L) .

Wygrywa najniższa liczba bajtów w każdym języku i obowiązują standardowe zasady gry w golfa .

Przypadki testowe

[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 bajtów

ÄOL¦ʒ%{γ€gË

Wypróbuj 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 bajtów

Dzięki Nie drzewo za zapisanie 4 bajtów.

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

Wypróbuj online!

Główną sztuczką golfa jest użycie sumy wartości bezwzględnych (lub 1-normalnej) sumy wartości kwadratowych, obliczonych jako iloczyn skalarny z samym sobą, jako górnej granicy zamiast Max@#-Min@#. W przeciwnym razie po prostu implementuje specyfikację bardzo dosłownie.

Perl 6 ,  52  48 bajtów

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

Sprawdź to

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

Sprawdź to

Rozszerzony:

{  # 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 bajtów

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

Wypróbuj online! Wykorzystuje sumę wartości bezwzględnych jako maksimum z odpowiedzi Martina Endera .

Edycja: -1 bajt dzięki Ørjan Johansen.

Wyjaśnienie:

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.

Łuska , 13 bajtów

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

Wypróbuj online!

R , 75 72 bajtów

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

Wypróbuj online!

Wykorzystuje tabledo obliczenia liczby każdego modulo liczby całkowitej x. Standardowe odchylenie sdzestawu liczb wynosi zero, jeśli wszystkie są równe, a w przeciwnym razie dodatnie. Stąd !sd(table(L%%x))jest TRUEwszędzie tam, gdzie Lmod jest zrównoważony mod, xa fałsz inaczej. Wartości te są następnie łączone w F.

whichnastępnie zwraca indeksy prawdziwych wartości z funkcji. Ponieważ R używa indeksowania opartego na 1 i Fjest początkowo wektorem długości o wartości 1 FALSE, to poprawnie zwróci wartości zaczynające się od2 .

Można oczekiwać, że wbudowana funkcja rangeobliczy zakres zestawu danych , tj. max(D)-min(D), Ale niestety oblicza i zwraca wektor c(min(D), max(D)).

Czysty , 121 bajtów

Wykorzystuje sztuczkę sumy absolutów z odpowiedzi Martina Endera.

Gra w golfa:

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]

Czytelny:

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]

Wypróbuj online!

Galaretka , 12 bajtów

⁹%LƙE
ASḊçÐf

Wypróbuj online!

Podziękowania dla user202729 za zapisanie bajtu i do Martinowi Enderowi (pośrednio) za zapisanie bajtu.

Jak to działa

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

Alternatywny 12-bajterowy wariant z jedną linią można wypróbować online!

Python 3, 120 102 bajtów

Niezbyt golfowy.

-18 bajtów dzięki 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)

Wypróbuj online!

MATL , 19 bajtów

-4 bajty dzięki Luisowi Mendo!

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

Wypróbuj online!

Port w mojej odpowiedzi w badania .

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 bajtów

Zwraca rozdzieloną spacjami listę wartości.

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)

Przypadki testowe

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 bajtów

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

Używanie frequenciesnie jest idealne w golfie kodu.

J, 38 bajtów

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

Podziękowania należą się panu Xcoderowi za sumę sztuczki wartości bezwzględnych.

Jeśli chcesz, edytuj link do TIO - trochę się spieszyłem.

Wyjaśnienie i link TIO już wkrótce (ish).

APL (Dyalog) , 43 41 38 30 bajtów

Litery w kodzie opowiadają całą historię.

8 bajtów zapisanych dzięki @ Adám

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

Wypróbuj online!