Desafio

Você é dado um array de inteiros. Com um movimento, você pode aumentar ou diminuir um elemento da matriz em 1 . Sua tarefa é equalizar a matriz, ou seja, igualar todos os elementos da matriz, executando alguns movimentos . Mas isso não basta! Você também deseja fazer o mínimo de movimentos possível .$a$

Entrada

• Uma matriz não vazia de números inteiros$a$
• Opcionalmente, o comprimento de .$a$

Saída

• O número mínimo de movimentos necessários para equalizar a matriz .$a$

Regras

• Aplicam-se regras padrão para envios válidos , E / S , brechas .
• Isso é código-golfe , e a solução mais curta (em bytes) vence. Como sempre, não permita que soluções ridiculamente curtas nos idiomas de golfe o desencorajem a postar uma resposta mais longa no idioma de sua escolha.
• Esta não é uma regra, mas sua resposta será melhor recebida se incluir um link para testar a solução e uma explicação de como ela funciona.

Exemplos

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 bytes

Tr@Abs[#-Median@#]&

Experimente online!

Para um array inteiro 1D, Trfunciona da mesma maneira que Total.

Quão?

Aplicação simples da desigualdade do triângulo.

...

Originalmente, pretendia escrever a prova aqui, mas, em seguida, decido procurar /math/ e encontrei A mediana minimiza a soma dos desvios absolutos (a norma ${L}_{1}$ ) .

Ao saber o nome do operador, esta é uma solução alternativa de 19 bytes:

Norm[#-Median@#,1]&

JavaScript (Node.js) , 50 48 bytes

Economizou 2 bytes graças a Arnauld

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

Experimente online!

Classifique a matriz ascendente e depois some:

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

05AB1E , 4 bytes

ÅmαO

Experimente online!

Explicação

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

Perl 6 , 29 28 bytes

-1 byte graças a nwellnhof

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

Experimente online!

Explicação

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

Japonês, 7 bytes

£xaXÃrm

Tente

Explicação

            :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

JavaScript (ES6), 60 56 55 bytes

Guardado 1 byte graças a @Shaggy

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

Experimente online!

Quão?

A menos que exista algum truque que esteja faltando, o cálculo da mediana em JS acaba sendo mais longo. Provavelmente em torno de 65 bytes devido ao retorno de chamada necessário para sort()contornar a classificação lexicográfica padrão e a longa duração Math.abs():

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

Em vez disso, tentamos todos os valores na matriz original como o valor de equalização .

Haskell , 34 bytes

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

Experimente online!

Encontra a distância total de todos os elementos para a mediana, testando cada elemento da lista como a mediana potencial e obtendo o menor resultado.

Gelatina , 4 bytes

ạÆṁS

Experimente online!

Como funciona

ạÆṁ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.

Python 2 , 46 bytes

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

Experimente online!

Leva o comprimento da lista ncomo argumento. Calcula a soma da metade superior menos a soma da metade inferior dividindo a lista classificada no primeiro n/2e no último n/2elementos.

A expressão l[-~n/2:l.sort()]é equivalente a computação l.sort(), que modifica a lista no lugar, em seguida, fazendo l[-~n/2:None], onde as listas de rejeição de corte limite superior Noneque l.sort()produzida. Pode parecer que a lista foi classificada tarde demais para ser cortada corretamente, mas o Python parece avaliar os argumentos da fatia antes de "travar" a lista a ser cortada.

Python 2 , 47 bytes

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

Experimente online!

O método chato de somar a distância de cada valor da mediana. Leva o comprimento ncomo argumento.

Python , 51 bytes

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

Experimente online!

Classifica a lista no local, adiciona repetidamente a última entrada (restante mais alto) menos a primeira (restante restante) e volta a aparecer na lista sem esses elementos até restarem apenas 0 ou 1. Usings pops' recebe o mesmo comprimento: l.pop()-l.pop(0)+f(l).

O l.sort()está preso em um local onde o Noneretorno não tem efeito. A fatia l[None:1]é a mesma que l[:1]porque Nones nas fatias são ignorados.

Python , 54 bytes

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

Experimente online!

Uma compreensão atraente da lista que ignora o argumento repetido e modifica a lista no local, repetidamente exibindo o primeiro e o último elementos. Garantimos que a compreensão da lista seja feita len(l)//2várias vezes, repetindo todos os outros elementos de lignorar o primeiro, terminado l[1::2]. A l.sort()produção Nonepode ficar presa no argumento de final de fatia não utilizado.

APL (Dyalog), 12 bytes

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

Forças brutas testando cada número como o equalizador. Não tenho certeza se tácito é mais curto, mas não consigo descobrir.

TIO

TI-Basic, 18 6 bytes

sum(abs(Ans-median(Ans

-12 bytes de Misha Lavrov (não utilizo o TI-Basic há algum tempo e esqueci que as listas podem fazer isso)

O TI-Basic é uma linguagem tokenizada . Todos os tokens usados ​​nesta resposta são de um byte.

Aceita entrada como {1,2,3,4}:prgmNAME

Basicamente, a mesma idéia que a maioria das outras respostas: subtraia pela mediana e depois faça a soma.

Explicação:

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

Röda , 33 bytes

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

Experimente online!

Explicação:

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

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

Experimente online!

Anexo , 18 bytes

Sum##Abs@`-#Median

Experimente online!

Explicação

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 bytes

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

Essencialmente o mesmo que a solução Japt de Shaggy.

Experimente online!

Como funciona?

|@-/~"{- cria uma tabela /~de diferenças absolutas |@-de cada número para todos os outros"{

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

1#. soma cada linha

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

[:<./ encontra o item menor (reduza no mínimo)

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

Carvão , 16 11 bytes

Ｉ⌊ＥθΣＥθ↔⁻ιλ

Experimente online! Link é a versão detalhada do código. Editar: salvou 5 bytes graças a @Arnauld. Explicação:

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

Visual C #, 138 bytes

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);

ungolfed:

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);

Experimente online!

C (gcc), 100 93 bytes

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;}

Solução de força bruta, tenta igualar com cada elemento. Experimente online aqui .

Agradecimentos ao ceilingcat por jogar 7 bytes.

Ungolfed:

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 bytes

Classifica a matriz e, em seguida, percorre uma cópia, retirando elementos do original e somando a diferença absoluta, que precisa ser reduzida pela metade para o retorno.

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])
);

Saída:

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

PHP, 69 bytes

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

função anônima. Experimente online .

JavaScript (Node.js) , 52 bytes

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

Experimente online!

Java (JDK), 112 bytes

Golfe

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;}

Ungolfed

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;
}

Kotlin Android, 200 bytes

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)}

Experimente on-line