ท้าทาย

คุณได้รับอาร์เรย์$a$จำนวนเต็ม ด้วยการย้ายคุณสามารถเพิ่มหรือลดองค์ประกอบของอาร์เรย์โดย 1 งานของคุณคือการเกลี่ยอาร์เรย์นั่นคือทำให้องค์ประกอบทั้งหมดของอาร์เรย์เท่ากับโดยการดำเนินการบางส่วนย้าย แต่นั่นยังไม่เพียงพอ! คุณยังต้องการที่จะทำเป็นเพียงการเคลื่อนไหวที่เป็นไปได้

อินพุต

• ไม่ว่างเปล่าอาร์เรย์ $a$ของจำนวนเต็ม
• เลือกที่มีความยาวของ$a$

เอาท์พุต

• จำนวนขั้นต่ำของการเคลื่อนไหวที่จำเป็นในการเกลี่ยอาร์เรย์$a$

กฎระเบียบ

• กฎระเบียบมาตรฐานสำหรับการส่งที่ถูกต้อง , I / O , ช่องโหว่ใช้
• นี่คือรหัส - กอล์ฟดังนั้นทางออกที่สั้นที่สุด (เป็นไบต์) ชนะ ตามปกติอย่าให้คำตอบสั้น ๆ อย่างน่าขันในภาษากอล์ฟกีดกันคุณจากการโพสต์คำตอบที่ยาวกว่าในภาษาที่คุณเลือก
• นี่ไม่ใช่กฎ แต่คำตอบของคุณจะได้รับดีกว่าถ้ามันมีลิงค์สำหรับทดสอบการแก้ปัญหาและคำอธิบายว่ามันทำงานอย่างไร

ตัวอย่าง

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 (Mathematica) , 19 ไบต์

Tr@Abs[#-Median@#]&

ลองออนไลน์!

สำหรับอาร์เรย์จำนวนเต็ม 1D TrทำงานในลักษณะเดียวกับTotalทำงานแบบเดียวกับ

อย่างไร?

แอพลิเคชันอย่างง่ายของความไม่เท่าเทียมกันของรูปสามเหลี่ยม

...

ฉันตั้งใจจะเขียนหลักฐานที่นี่ แต่แล้วตัดสินใจค้นหาhttps://math.stackexchange.comแทนและพบว่าThe Median ลดผลรวมของการเบี่ยงเบนสัมบูรณ์ ( ${L}_{1}$ Norm) Norm)

ด้วยการทราบชื่อของโอเปอเรเตอร์นี่เป็นทางเลือกแบบ 19 ไบต์:

Norm[#-Median@#,1]&

JavaScript (Node.js) , 50 48 ไบต์

บันทึก 2 ไบต์ขอบคุณ Arnauld

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

Perl 6 , 29 28 ไบต์

-1 ไบต์ต้องขอบคุณ nwellnhof

{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

Japtap, 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

JavaScript (ES6), 60 56 55 ไบต์

บันทึก 1 ไบต์ขอบคุณ @Shaggy

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

แต่การที่เราพยายามค่าทั้งหมดในอาร์เรย์เดิมเป็นอีควอไลคุ้มค่า

Haskell , 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.

Python 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 ดูเหมือนจะประเมินอาร์กิวเมนต์ของ slice ก่อนที่จะทำการ "lock in" รายการที่จะทำการแบ่ง

Python 2 , 47 ไบต์

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

ลองออนไลน์!

วิธีการที่น่าเบื่อของการรวมระยะทางของแต่ละค่าจากค่ามัธยฐาน ใช้ความยาวnเป็นอาร์กิวเมนต์

Pythonขนาด 51 ไบต์

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

ลองออนไลน์!

เรียงลำดับรายการในสถานที่จากนั้นเพิ่มรายการสุดท้าย (เหลือสูงสุด) ซ้ำ ๆ ลบรายการแรก (เหลือน้อยที่สุด) และเรียกรายการซ้ำโดยไม่มีองค์ประกอบเหล่านี้จนกว่าจะเหลือเพียง 0 หรือ 1 Usingspop 's l.pop()-l.pop(0)+f(l)ได้รับระยะเวลาเดียวกัน:

l.sort()จะติดอยู่ในสถานที่ที่ที่Noneมันกลับไม่มีผล Slice l[None:1]เป็นเช่นเดียวกับl[:1]เนื่องจากNones เป็นชิ้นจะถูกละเว้น

Pythonขนาด 54 ไบต์

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

ลองออนไลน์!

ความเข้าใจในรายการที่น่ารักที่ไม่สนใจอาร์กิวเมนต์ที่วนซ้ำและแก้ไขรายการให้เข้าที่โดยการเปิดองค์ประกอบแรกและองค์ประกอบสุดท้ายซ้ำ ๆ เรามั่นใจว่าเข้าใจรายการจะทำlen(l)//2ครั้งโดย iterating กว่าองค์ประกอบอื่น ๆ ทุกการกระโดดครั้งแรกที่ทำกับl l[1::2]การl.sort()ผลิตNoneสามารถติดอยู่ในอาร์กิวเมนต์สิ้นสุดชิ้นที่ไม่ได้ใช้

APL (Dyalog) ขนาด 12 ไบต์

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

เดรัจฉานกองกำลังโดยการทดสอบแต่ละหมายเลขเป็นอีควอไลเซอร์ ไม่แน่ใจว่าเงียบโดยปริยาย แต่ฉันไม่สามารถเข้าใจได้

TIO

TI-Basic, 18 6 ไบต์

sum(abs(Ans-median(Ans

-12 bytes จากMisha Lavrov (ฉันไม่ได้ใช้ TI-Basic สักพักแล้วและฉันก็ลืมว่ามันสามารถทำรายการได้)

TI-Basic เป็นภาษาโทเค็น โทเค็นทั้งหมดที่ใช้ในคำตอบนี้เป็นหนึ่งไบต์

ใช้อินพุตเป็น {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

Röda , 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#.|@-/~"{

เป็นหลักเช่นเดียวกับโซลูชัน Japt ของ Shaggy

ลองออนไลน์!

มันทำงานอย่างไร?

|@-/~"{- สร้างตาราง/~ของความแตกต่างที่แน่นอน|@-ของแต่ละตัวเลขให้กับคนอื่น ๆ ทั้งหมด"{

   |@-/~"{ 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 ไบต์

Ｉ⌊ＥθΣＥθ↔⁻ιλ

ลองออนไลน์! การเชื่อมโยงคือการใช้รหัสเวอร์ชันอย่างละเอียด แก้ไข: บันทึก 5 ไบต์ขอบคุณ @Arnauld คำอธิบาย:

  Ｅθ        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 ไบต์

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

ลองออนไลน์!

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 ไบต์

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 ไบต์

เรียงลำดับอาร์เรย์จากนั้นวนรอบสำเนาคัดลอกองค์ประกอบออกจากต้นฉบับและรวมความแตกต่างที่แน่นอนที่จะต้องลดลงครึ่งหนึ่งสำหรับการกลับมา

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

ฟังก์ชั่นไม่ระบุชื่อ ลองมันออนไลน์

JavaScript (Node.js) , 52 ไบต์

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

ลองออนไลน์!

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

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 ไบต์

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

ลองออนไลน์