Einführung

Angenommen, ich habe eine Liste von ganzen Zahlen, sagen wir L = [-1,2,2,1,2,7,1,4] . Ich mag Balance in meinem Leben, deshalb bin ich froh zu sehen, dass es so viele seltsame Elemente wie gerade Elemente hat. Darüber hinaus enthält es in allen Modulo-Klassen von 3 die gleiche Anzahl von Elementen, in denen es Elemente enthält:

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

Leider gilt dies für die Modulo-Klassen von 4 nicht mehr. Im Allgemeinen sagen wir, dass eine nicht leere Liste ausgeglichenes Modulo N ist, wenn sie eine gleiche Anzahl von Elementen in allen Moduloklassen von N hat, für die diese Zahl nicht 0 ist. Die obige Liste L ist ausgeglichenes Modulo 2 und 3, aber unsymmetrisches Modulo 4.

Die Aufgabe

Ihre Eingabe ist eine nicht leere Liste L von ganzen Zahlen, die in einem angemessenen Format erstellt wurden. Ihre Ausgabe ist die Liste dieser ganzen Zahlen N ≥ 2, so dass L modulo N ausgeglichen ist , wiederum in jedem vernünftigen Format. Die Reihenfolge der Ausgabe spielt keine Rolle, sie sollte jedoch keine Duplikate enthalten.

Es ist garantiert, dass die Ausgabe nur endlich viele Zahlen enthält, was genau bedeutet, dass nicht alle Elemente von L gleich oft darin vorkommen. Beispiele für ungültige Eingaben sind [3] , [1,2] und [0,4,4,0,3,3] . Beachten Sie, dass die größte Zahl in der Ausgabe höchstens max (L) - min (L) beträgt .

Die niedrigste Byteanzahl in jeder Sprache gewinnt, und es gelten die Standardregeln für Code-Golf .

Testfälle

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

Probieren Sie es 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

Danke an Not a tree für das Speichern von 4 Bytes.

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

Probieren Sie es online!

Der Haupttrick beim Golfen besteht darin, die Summe der Absolutwerte (oder die 1-Norm) der quadrierten Werte, die als Skalarprodukt mit sich selbst berechnet wurden, als Obergrenze anstelle von zu verwenden Max@#-Min@#. Ansonsten wird die Spezifikation nur sehr wörtlich umgesetzt.

Perl 6 ,  52  48 Bytes

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

Probier es aus

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

Probier es aus

Erweitert:

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

Probieren Sie es online! Verwendet die Summe der absoluten Werte als Maximum aus Martin Enders Antwort .

Edit: -1 Byte danke an Ørjan Johansen.

Erläuterung:

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.

Schale , 13 Bytes

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

Probieren Sie es online!

R , 75 72 Bytes

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

Probieren Sie es online!

Verwendet table, um die Anzahl der einzelnen Ganzzahlmodule zu berechnen x. Die Standardabweichung sdeiner Reihe von Zahlen ist Null, wenn sie alle gleich sind, und ansonsten positiv. Daher !sd(table(L%%x))ist TRUEüberall Lmod-balanciert xund sonst falsch. Diese Werte werden dann in verkettet F.

whichgibt dann die Indizes der wahren Werte von der Funktion zurück. Da R eine 1-basierte Indizierung verwendet und Fanfänglich ein Vektor der Länge eins mit Wert ist FALSE, gibt dies Werte zurück, die mit beginnen 2.

Man könnte die eingebaute Funktion erwarten rangedie zur Berechnung Bereich eines Datensatzes , das heißt max(D)-min(D), aber leider es berechnet und gibt den Vektor c(min(D), max(D)).

Sauber , 121 Bytes

Verwendet die Summe der absoluten Tricks aus Martin Enders Antwort.

Golf gespielt:

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]

Lesbar:

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]

Probieren Sie es online!

Gelee , 12 Bytes

⁹%LƙE
ASḊçÐf

Probieren Sie es online!

Vielen Dank an user202729 für das Speichern eines Bytes und an Martin Ender (indirekt) für das Speichern eines Bytes.

Wie es funktioniert

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

Eine einzeilige Alternative 12-Byte kann online ausprobiert werden!

Python 3, 120 102 Bytes

Nicht ganz so golfen.

-18 Bytes dank 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)

Probieren Sie es online!

MATL , 19 Bytes

-4 Bytes dank Luis Mendo!

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

Probieren Sie es online!

Port meiner Antwort 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

Gibt eine durch Leerzeichen getrennte Liste von Werten aus.

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)

Testfälle

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)

Verwenden frequenciesist im Code-Golf nicht ideal.

J, 38 Bytes

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

Die Summe der absoluten Werte wird Herrn Xcoder gutgeschrieben.

Bearbeiten Sie in einem TIO-Link, wenn Sie möchten.

Erklärung und TIO-Link folgen in Kürze (ish).

APL (Dyalog) , 43 41 38 30 Bytes

Das ⍨s im Code erzählt die ganze Geschichte.

8 Bytes gespart dank @ Adám

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

Probieren Sie es online!