소개

L = [-1,2,2,1,2,7,1,4] 와 같은 정수 목록이 있다고 가정하십시오 . 나는 내 인생에서 균형을 유지하는 것을 좋아하기 때문에 그것이 짝수 요소만큼 많은 이상한 요소를 가지고 있음을 알게되어 기쁩니다. 또한 모든 모듈로 클래스 3에 동일한 수의 요소가 있으며 요소는 다음과 같습니다.

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

슬프게도, 모듈로 클래스 4의 경우 더 이상 유지되지 않습니다. 일반적으로, 우리는 비어 목록을 받았다고 모듈 균형 N 은 모든 모듈의 종류의 요소의 동일한 수의 경우 N 이 수가 상기리스트 0되지 않은 L은 밸런스 모듈 (2, 3)이며, 그러나 불균형 모듈 4.

작업

귀하의 입력은 임의의 합리적인 형식으로 취한 정수 가 아닌 비어있는 목록 L 입니다. 출력은 L ≥ 2 인 정수 N ≥ 2 의 목록이며 , L 은 균형 잡힌 형식으로 다시 모듈로 N 입니다. 출력 순서는 중요하지 않지만 중복을 포함해서는 안됩니다.

출력에 유한하게 많은 수의 숫자가 있다는 것이 보장됩니다. 이는 L의 모든 요소가 같은 수의 숫자로 나오는 것은 아니라는 것을 의미 합니다. 유효하지 않은 입력의 예는 [3] , [1,2] 및 [0,4,4,0,3,3] 입니다. 출력에서 가장 큰 숫자는 최대 max (L)-min (L) 입니다.

각 언어에서 가장 낮은 바이트 수가 이기고 표준 코드 골프 규칙이 적용됩니다.

테스트 사례

[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 바이트

ÄOL¦ʒ%{γ€gË

온라인으로 사용해보십시오!

Ä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 바이트

4 바이트를 절약 할 수있는 Tree가 아니기 때문입니다.

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

온라인으로 사용해보십시오!

주요 골프 트릭은 자체의 내적으로 계산 된 절대 값 의 합 (또는 1- 노름) 제곱 값의 합을 대신 상한으로 사용하는 것입니다 Max@#-Min@#. 그렇지 않으면 스펙을 문자 그대로 구현합니다.

펄 6 ,  52  48 바이트

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

그것을 테스트

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

그것을 테스트

넓히는:

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

하스켈 , 85 84 바이트

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

온라인으로 사용해보십시오! Martin Ender의 답변 에서 최대 값으로 절대 값의 합을 사용합니다 .

편집 : Ørjan Johansen 덕분에 -1 바이트.

설명:

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.

껍질 , 13 바이트

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

온라인으로 사용해보십시오!

R , 75 72 바이트

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

온라인으로 사용해보십시오!

용도는 table각 정수 모듈의 수를 계산합니다 x. sd숫자 집합의 표준 편차 는 모두 같으면 0이고 그렇지 않으면 양수입니다. 따라서 모드 밸런스 모드 !sd(table(L%%x))가 TRUE어디에 있든 그렇지 않으면 false입니다. 그런 다음이 값은로 연결됩니다 .LxF

which그런 다음 함수에서 참 값의 인덱스를 반환합니다. R은 1 기반 인덱싱을 사용하고 F처음에는 value가있는 길이가 1 인 벡터 FALSE이므로로 시작하는 값을 올바르게 반환합니다 2.

내장 함수 range가 데이터 세트 의 범위 를 계산할 것으로 기대할 수 있습니다. , 즉 max(D)-min(D)슬프게도 벡터를 계산하고 반환c(min(D), max(D)) .

깨끗한 , 121 바이트

Martin Ender의 답변에서 절대 합계를 사용합니다.

골프 :

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]

읽을 수있는 :

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]

온라인으로 사용해보십시오!

젤리 , 12 바이트

⁹%LƙE
ASḊçÐf

온라인으로 사용해보십시오!

바이트를 저장 한 user202729 와 바이트를 저장 한 Martin Ender (간접적으로)에게 감사합니다 .

작동 원리

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

1 라이너 대안 12 바이 터는 온라인 으로 시도 할 수 있습니다 !

파이썬 3 120 102 바이트

꽤 골프가 아닙니다.

Mr. Xcoder 덕분에 -18 바이트 .

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)

온라인으로 사용해보십시오!

MATL , 19 바이트

Luis Mendo 덕분에 -4 바이트 !

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

온라인으로 사용해보십시오!

내 대답의 포트는 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

자바 스크립트 (ES6), 117 바이트

공백으로 구분 된 값 목록을 출력합니다.

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)

테스트 사례

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]

클로저, 91 바이트

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

frequencies코드 골프에서는 사용하는 것이 이상적이지 않습니다.

J, 38 바이트

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

신용은 절대 가치 트릭의 합으로 Xcoder에게갑니다.

원하는 경우 TIO 링크에서 편집하십시오. 서두르는 데 골프를 쳤습니다.

설명 및 TIO 링크가 곧 제공됩니다 (ish).

APL (Dyalog) , 43 41 38 30 바이트

코드의 ⍨는 전체 이야기를 알려줍니다.

@ Adám 덕분에 8 바이트 절약

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

온라인으로 사용해보십시오!