Meydan okuma

Bir dizi verilir $a$ tamsayılar. Bir ile hareket yapabilirsiniz artırmak veya azaltmak dizi öğe 1 ile . Göreviniz diziyi eşitlemek , bu da bazı hareketleri gerçekleştirerek dizinin tüm öğelerini eşitlemektir . Ama bu yeterli değil! Ayrıca mümkün olduğunca az hamle yapmak istersiniz .

Giriş

• Boş olmayan bir dizi $a$ tamsayı
• İsteğe bağlı olarak, uzunluk ve $a$ .

Çıktı

• Minimum sayıda hareket için gerekli eşitlemek dizi $a$ .

kurallar

• Geçerli gönderimler için standart kurallar , G / Ç , boşluklar geçerlidir.
• Bu kod golf , yani en kısa çözüm (bayt cinsinden) kazanır. Her zamanki gibi, golfçü dillerde saçma sapan kısa çözümlerin, seçtiğiniz dilde daha uzun bir cevap göndermekten vazgeçmesine izin vermeyin.
• Bu bir kural değildir, ancak çözümü test etmek için bir bağlantı ve nasıl çalıştığı hakkında bir açıklama içeriyorsa, cevabınız daha iyi alınacaktır.

Örnekler

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 Dili (Mathematica) , 19 bayt

Tr@Abs[#-Median@#]&

Çevrimiçi deneyin!

1D tamsayı dizisi Triçin aynı şekilde çalışır Total.

Nasıl?

Üçgen eşitsizliğinin basit uygulaması.

...

İlk önce ispatı buraya yazmayı düşündüm, fakat sonra bunun yerine https://math.stackexchange.com adresini aramaya karar verdim ve Medyan Mutlak Sapmaların Toplamını ( ${L}_{1}$ Normu) En Aza İndirdi .

Operatörün adını bilerek, bu alternatif bir 19 baytlık çözümdür:

Norm[#-Median@#,1]&

JavaScript (Node.js) , 50 48 bayt

Arnauld sayesinde 2 bayt kaydedildi

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

Çevrimiçi deneyin!

Artan diziyi sıralayın ve toplayın:

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

05AB1E , 4 bayt

ÅmαO

Çevrimiçi deneyin!

açıklama

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

Perl 6 , 29 28 bayt

Nwellnhof sayesinde -1 bayt

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

Çevrimiçi deneyin!

açıklama

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

Japt, 7 bayt

£xaXÃrm

Dene

açıklama

            :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 bayt

@Shaggy sayesinde 1 bayt kaydedildi

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

Çevrimiçi deneyin!

Nasıl?

Kaçırdığım bir numara olmadığı sürece, JS'deki medyanı hesaplamak daha uzun sürüyor. Varsayılan sözlükbilgisi türünü ve daha uzun olanı atlatmak için gereken geri arama nedeniyle muhtemelen yaklaşık 65 bayt :sort()Math.abs()

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

Bunun yerine, orijinal dizideki tüm değerleri eşitleme değeri olarak deneriz .

Haskell , 34 bayt

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

Çevrimiçi deneyin!

Tüm öğelerin medyanla toplam mesafesini bulur, listedeki her öğeyi potansiyel medyan olarak test eder ve en küçük sonucu alır.

Jöle , 4 bayt

ạÆṁS

Çevrimiçi deneyin!

Nasıl çalışır

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

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

Çevrimiçi deneyin!

Liste uzunluğunu nargüman olarak alır. Sıralanan listeyi birinci n/2ve son dilime ayırarak üst yarı toplamı eksi alt yarı toplamı hesaplarn/2 öğelere .

Sentezleme l[-~n/2:l.sort()]işlem eşdeğerdir l.sort()durumu, daha sonra, bir yer değiştirir listesini l[-~n/2:None]listesi dilimleme zaman göz ardı edilen üst sınırı burada, Nonebu l.sort()üretti. Doğru dilimlemek için liste çok geç sıralanmış gibi görünebilir, ancak Python dilimlenmiş listeyi "kilitlemeden" önce dilim argümanlarını değerlendiriyor gibi görünebilir.

Python 2 , 47 bayt

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

Çevrimiçi deneyin!

Her değerin medyandan uzaklığını toplama sıkıcı yöntemi. Uzunluğu nbir argüman olarak alır.

Python , 51 bayt

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

Çevrimiçi deneyin!

Listeyi yerinde sıralar, ardından ilk (kalan en yüksek) girişi eksi ilk (en düşük kalan) girişi ekleyerek tekrar tekrar ekler ve yalnızca 0 veya 1 kalana kadar bu öğeler olmadan listeye yeniden girer. Usings pop'ın aynı uzunlukta olur: l.pop()-l.pop(0)+f(l).

l.sort()Bir yerde kalmış Nonehiçbir etkisi yoktur döndürür. Dilim l[None:1]aynıdır l[:1]çünkü Nonedilimler halinde ler dikkate alınmaz.

Python , 54 bayt

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

Çevrimiçi deneyin!

Yinelenen argümanı yok sayan ve listeyi ilk ve son elemanları tekrar tekrar tıklatarak değiştiren sevimli bir liste anlayışı. İlk önce atlayan len(l)//2diğer öğelerin üzerine latlayarak listenin kavranmasının zamanla yapılmasını sağlıyoruz l[1::2]. l.sort()Üretim Nonekullanılmayan dilim uç argümanı takılıp olabilir.

APL (Dyalog), 12 bayt

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

Her sayıyı ekolayzer olarak test ederek kuvvetleri alın. Yapışkanlığın daha kısa olup olmadığından emin değilim, ama çözemiyorum.

TIO

TI-Basic, 18 6 bayt

sum(abs(Ans-median(Ans

Dan -12 bayt Misha Lavrov (Bir süredir TI-Basic kullanmadıysanız ve onun 'için listeleri yapabilir unuttum)

TI-Basic belirtilmiş bir dildir . Bu cevapta kullanılan tüm belirteçler bir bayttır.

Girişi alır {1,2,3,4}:prgmNAME

Temel olarak diğer cevapların çoğunda aynı fikir: medyan tarafından çıkar, sonra toplamı al.

Açıklama:

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 bayt

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

Çevrimiçi deneyin!

Açıklama:

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

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

Çevrimiçi deneyin!

Ataşesi , 18 bayt

Sum##Abs@`-#Median

Çevrimiçi deneyin!

açıklama

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 bayt

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

Temelde Shaggy'nin Japt çözümü ile aynı.

Çevrimiçi deneyin!

Nasıl çalışır?

|@-/~"{- her sayının diğerlerine /~mutlak farklar tablosu yaratır|@-"{

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

1#. her satırı toplar

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

[:<./ En küçük öğeyi bulur (en aza indirgemek)

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

Kömür , 16 11 bayt

Ｉ⌊ＥθΣＥθ↔⁻ιλ

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı bir versiyonudur. Düzenleme: @Arnauld sayesinde 5 bayt kaydedildi. Açıklama:

  Ｅθ        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 bayt

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

Çevrimiçi deneyin!

C (gcc), 100 93 bayt

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

Kaba kuvvet çözümü, her elemanla eşitlenmeye çalışır. Burada çevrimiçi deneyin .

7 bayt golf oynamak için ceilingcat sayesinde .

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 bayt

Diziyi sıralar, sonra bir kopyasını döndürür, öğeleri orijinalin dışına fırlatır ve dönüş için yarıya inmesi gereken mutlak farkı toplar.

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

Çıktı:

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

PHP, 69 bayt

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

adsız işlev Çevrimiçi deneyin .

JavaScript (Node.js) , 52 bayt

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

Çevrimiçi deneyin!

Java (JDK), 112 bayt

golfed

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 bayt

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

Çevrimiçi dene