도전

당신은 배열 주어진다 정수를. A의 이동 을 할 수 있습니다 증가 또는 감소 배열의 요소를 1 . 당신의 임무는 배열 을 균등화 하는 것입니다. 즉, 약간의 움직임 을 수행하여 배열의 모든 요소를 ​​동일하게 만듭니다. 그러나 충분하지 않습니다! 또한 가능한 적은 이동 을 원합니다 .$a$

입력

• 비어 있지 않은 배열 정수$a$
• 선택적으로 길이 는 .$a$

산출

• 최소 번호 이동 하는데 필요한 균등 배열 $a$ .

규칙

• 유효한 제출 , I / O , 허점에 대한 표준 규칙 이 적용됩니다.
• 이것은 code-golf 이므로 가장 짧은 솔루션 (바이트)이 이깁니다. 평소와 같이, 골프 언어로 된 엄청나게 짧은 해결책이 선택한 언어로 더 긴 답변을 올리는 것을 방해하지 마십시오.
• 이것은 규칙이 아니지만 솔루션을 테스트하기위한 링크와 작동 방식에 대한 설명이 포함 된 경우 답변이 더 잘 수신됩니다.

예

Input                       --> Output

[10]                        --> 0
[-1, 0, 1]                  --> 2
[4, 7]                      --> 3
[6, 2, 3, 8]                --> 9
[5, 8, 12, 3, 2, 8, 4, 5]   --> 19
[1,10,100]                  --> 99

Wolfram Language (Mathematica) , 19 바이트

Tr@Abs[#-Median@#]&

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

1D 정수 배열의 Tr경우와 같은 방식으로 작동합니다 Total.

방법?

삼각형 부등식의 간단한 적용.

...

나는 원래 여기에 증거를 쓰려고했지만 대신 https://math.stackexchange.com 을 찾아 중간 값이 절대 편차의 합을 최소화하는${L}_{1}$ 것을 발견했습니다 ( Norm) .

운영자의 이름을 알면 대체 19 바이트 솔루션입니다.

Norm[#-Median@#,1]&

자바 스크립트 (Node.js) , 50 48 바이트

Arnauld 덕분에 2 바이트 절약

a=>a.sort((x,y)=>x-y,r=0).map(n=>r+=a.pop()-n)|r

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

배열을 오름차순으로 정렬 한 다음 합계하십시오.

  a[last]   -a[0] // moves to equalise this pair
+ a[last-1] -a[1] // + moves to equalise this pair
+ ...etc

05AB1E , 4 바이트

ÅmαO

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

설명

Åm     # push median of input
  α    # absolute difference with each in input
   O   # sum

펄 6 , 29 28 바이트

nwellnhof 덕분에 -1 바이트

{sum (.sort[*/2]X-$_)>>.abs}

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

설명

{                          }  # Anonymous code block
      .sort[*/2]              # Get the median of the input array
                X-$_          # Subtract all elements from the median
     (              )>>.abs   # Get the absolute of each value
 sum                          # Sum the values

apt, 7 바이트

£xaXÃrm

시도 해봐

설명

            :Implicit input of array U
£           :Map each X
  aX        :  Absolute difference between X and each element in U
 x          :  Reduce by addition
    Ã       :End map
     rm     :Reduce by minimum

자바 스크립트 (ES6), 60 56 55 바이트

@Shaggy 덕분에 1 바이트 절약

a=>a.map(r=k=>r=a.map(n=>m+=n>k?n-k:k-n,m=0)|m>r?r:m)|r

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

방법?

내가 놓친 몇 가지 트릭이 없으면 JS의 중간 값 계산이 더 길어집니다. 아마도 기본 어휘 정렬을 피하기 위해 필요한 콜백 과 다소 긴 길이 때문에 아마도 약 65 바이트 입니다 .sort()Math.abs()

a=>a.sort((a,b)=>b-a).map(n=>s+=Math.abs(n-a[a.length>>1]),s=0)|s

대신 원래 배열의 모든 값을 이퀄라이징 값 으로 시도합니다 .

하스켈 , 34 바이트

f l=minimum[sum$abs.(m-)<$>l|m<-l]

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

모든 요소와 중앙값까지의 총 거리를 찾아 목록의 각 요소를 잠재적 중앙값으로 테스트하고 가장 작은 결과를 얻습니다.

젤리 , 4 바이트

ạÆṁS

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

작동 원리

ạÆṁS – Full program. Takes an array A of integers as input from argument 1.
 Æṁ  – Median. For odd-length A, middle element of S. For even-length A, the
       arithmetic mean of the two middle elements of S. Where S = A sorted.
ạ    – Absolute difference of each element with the median.
   S – Sum.

파이썬 2 , 46 바이트

lambda l,n:sum(l[-~n/2:l.sort()])-sum(l[:n/2])

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

리스트 길이 n를 인수로 사용합니다. 정렬 된 목록을 첫 번째 요소 n/2와 마지막 n/2요소 로 분할하여 상위 절반 합계에서 하위 절반 합계를 뺍니다 .

표현은 l[-~n/2:l.sort()]컴퓨팅 동등 l.sort()하고 그런 다음 장소 수정리스트 l[-~n/2:None]목록 슬라이싱 무시가 상부의 경계 여기서 None그 l.sort()제조. 목록이 너무 늦게 정렬되어 올바르게 정렬되지 않은 것처럼 보이지만 Python은 목록을 "잠그기"전에 슬라이스 인수를 평가하는 것 같습니다.

파이썬 2 , 47 바이트

lambda l,n:sum(abs(x-sorted(l)[n/2])for x in l)

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

중앙값에서 각 값의 거리를 합산하는 지루한 방법입니다. 길이 n를 인수로 사용합니다.

파이썬 , 51 바이트

f=lambda l:l>l[l.sort():1]and l[-1]-l[0]+f(l[1:-1])

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

목록을 제자리에 정렬 한 다음 마지막 (가장 높은) 항목에서 첫 번째 (가장 낮은) 항목을 뺀 반복적으로 추가하고 0 또는 1 만 남을 때까지 이러한 요소없이 목록에서 반복합니다. Usings pop의 길이는 동일합니다 : l.pop()-l.pop(0)+f(l).

는 l.sort()장소에 갇혀있다 None가 아무 효과가 없습니다 반환합니다. 슬라이스 의 s가 무시 되므로 슬라이스 l[None:1]는 동일 합니다.l[:1]None

파이썬 , 54 바이트

lambda l:sum(l.pop()-l.pop(0)for _ in l[1:l.sort():2])

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

반복되는 인수를 무시하고 첫 번째 요소와 마지막 요소를 반복해서 팝업하여 목록을 수정하는 귀여운 목록 이해 우리는을 사용 하여 첫 번째 len(l)//2를 l건너 뛰는 다른 모든 요소를 ​​반복 하여 목록 이해가 시간을 수행하도록 l[1::2]합니다. l.sort()을 일으키기는 None사용되지 않는 슬라이스 최종 인수에 붙어있을 수 있습니다.

APL (Dyalog), 12 바이트

{⌊/+/|⍵∘.-⍵}

각 숫자를 이퀄라이저로 테스트하여 무차별 대입. 암묵이 더 짧은 지 확실하지 않지만 알아낼 수 없습니다.

TIO

TI 기본, 18 6 바이트

sum(abs(Ans-median(Ans

Misha Lavrov 에서 -12 바이트 (한동안 TI-Basic을 사용하지 않았으며 목록에서 그렇게 할 수 있음을 잊었습니다)

TI-Basic은 토큰 화 된 언어 입니다. 이 답변에 사용 된 모든 토큰은 1 바이트입니다.

다음과 같이 입력을받습니다. {1,2,3,4}:prgmNAME

기본적으로 대부분의 다른 답변과 동일한 아이디어 : 중앙값을 뺀 다음 합계를 취하십시오.

설명:

sum(abs(Ans-median(Ans
sum(                    # 1 byte, Add up:
    abs(                # 1 byte, the absolute values of
        Ans-median(Ans  # 4 bytes, the differences between each element and the list's median

로다 , 33 바이트

{|a|a|abs _-[sort(a)][#a//2]|sum}

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

설명:

{|a| /* Anonymous function with parameter a */
  a|         /* Push items in a to the stream */
             /* For each _ in the stream: */
  abs        /*   Abstract value of */\
  _-         /*   the value from stream minus */\
  [sort(a)][ /*     the value in the sorted version of a at index */
    #a//2    /*       length of a / 2 (the median) */
  ]|
  sum        /* Sum of all values in the stream */
}

R , 29 바이트

sum(abs(median(a<-scan())-a))

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

첨부 , 18 바이트

Sum##Abs@`-#Median

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

설명

Sum##Abs@`-#Median
            Median    take the median of the input list
     Abs@`-#          absolute difference with the original list
Sum##                 sum of all elements

J , 15 바이트

[:<./1#.|@-/~"{

Shaggy의 Japt 솔루션과 기본적으로 동일합니다.

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

어떻게 작동합니까?

|@-/~"{- /~다른 |@-모든 숫자 와의 절대적인 차이 테이블 을 만듭니다."{

   |@-/~"{ 6 2 3 8
0 4 3 2
4 0 1 6
3 1 0 5
2 6 5 0

1#. 각 행을 합산

   1#.|@-/~"{ 6 2 3 8
9 11 9 13

[:<./ 가장 작은 항목을 찾습니다 (최소로 줄임)

   ([:<./1#.|@-/~"{) 6 2 3 8
9

숯 , 16 11 바이트

Ｉ⌊ＥθΣＥθ↔⁻ιλ

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. 편집 : @Arnauld 덕분에 5 바이트가 절약되었습니다. 설명:

  Ｅθ        Map over input array
     Ｅθ     Map over input array
         ι  Outer value
          λ Inner value
        ⁻   Difference
       ↔    Absolute value
    Σ       Sum
 ⌊          Minimum
Ｉ           Cast to string
            Implicitly print

비주얼 C #, 138 바이트

int s=0;foreach(string i in a)s+=int.Parse(i);int x=s/a.Length;int o=0;foreach(string i in a)o+=Math.Abs(int.Parse(i)-x);Console.Write(o);

언 골프 :

int s = 0;                    // Takes a string array of arguments a as input
foreach (string i in a)       
     s += int.Parse(i);       // s as sum of the array elements
int x = s / a.Length;         // calculating the target value of all elements
int o = 0;                    // o as minimum number of moves
foreach (string i in a)
     o += Math.Abs(int.Parse(i) - x);    // summing up the moves to the target value
Console.Write(o);

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

C (gcc), 100 93 바이트

e(q,u,a,l,i,z)int*q;{i=1<<31-1;for(a=u;a--;i=z<i?z:i)for(l=z=0;l<u;)z+=abs(q[l++]-q[a]);q=i;}

무차별 대입 솔루션은 각 요소와 균등화를 시도합니다. 여기에서 온라인으로 사용해보십시오 .

7 바이트 골프 용 실링 캣 덕분 입니다.

언 골프 드 :

e(q, u, a, l, i, z) int *q; { // function taking an array of int and its length; returns an int (extra parameters are variables and don't have to be passed when calling e())
    i = 1 << 31 - 1; // construt the maximum value of a signed 4-byte integer
    for(a = u; a--; i = z < i ? z : i) // loop through the array, testing each element as the equalizer; if the number of moves is smaller than the current minimum, set it as the new minimum
        for(l = z = 0; l < u; ) // loop through the array ...
            z += abs(q[l++] - q[a]); // ... and sum the number of moves it takes to equalize each element
    q = i; // return the minimum number of moves
}

PHP, 78 바이트

배열을 정렬 한 다음 복사본을 반복하여 원본에서 요소를 빼내고 절대 차이를 합산하여 반환을 위해 반으로 줄여야합니다.

function m($n){sort($n);foreach($n as$i)$r+=abs(array_pop($n)-$i);return$r/2;}

var_dump(
    m([10]),
    m([-1, 0, 1]),
    m([4, 7]),
    m([6, 2, 3, 8]),
    m([5, 8, 12, 3, 2, 8, 4, 5]),
    m([1,10,100])
);

산출:

int(0)
int(2)
int(3)
int(9)
int(19)
int(99)

PHP, 69 바이트

function($a,$c){for(sort($a);$c-->$d;)$s+=$a[$c]-$a[+$d++];return$s;}

익명의 기능. 온라인으로 사용해보십시오 .

자바 스크립트 (Node.js) , 52 바이트

f=a=>(v=a.sort((x,y)=>x-y).pop()-a.shift())?v+f(a):0

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

자바 (JDK), 112 바이트

골프

private static int e(int[]a){int s=0;for(int i:a){s+=i;}s/=a.length;int r=0;for(int i:a){r+=abs(s-i);}return r;}

언 골프

private static int equalize(int[] array) {
    int sum = 0;
    for (int i : array) {
        sum += i;
    }
    sum /= array.length;
    int ret = 0;
    for (int i : array) {
        ret += abs(sum-i);
    }
    return ret;
}

코 틀린 안드로이드, 200 바이트

fun m(a:IntArray){var d=0;var s=0;var p=a.max()!!.times(a.size);var x =0;for(i in a.indices){x=a[i];d=0;s=0;while(d<a.size){if(x-a[d]<0)s=((x-a[d])*-1)+s;else s=((x-a[d]))+s;d++};if(p>s)p=s};print(p)}

온라인 시도