सरणी के बराबर करें

Question

चुनौती

आपको पूर्णांक की एक सरणी दी जाती है । एक चाल से आप सरणी के एक तत्व को 1 से बढ़ा या घटा सकते हैं । आपका कार्य सरणी को बराबर करना है, जो कुछ चालों को निष्पादित करके सरणी के सभी तत्वों को समान बनाता है । लेकिन इतना ही काफी नहीं है! आप भी संभव के रूप में कुछ कदम बनाने के लिए चाहते हैं ।$a$

इनपुट

• एक गैर खाली सरणी पूर्णांक$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

Answer 1

वोल्फ्राम भाषा (गणितज्ञ) , 19 बाइट्स

Tr@Abs[#-Median@#]&

इसे ऑनलाइन आज़माएं!

1D पूर्णांक सरणी के लिए, Trउसी तरह काम करता है Total।

कैसे?

त्रिभुज असमानता का सरल अनुप्रयोग।

...

मैंने मूल रूप से यहाँ प्रमाण लिखने का इरादा किया था, लेकिन फिर इसके बजाय /math/ देखने का निर्णय लिया और पाया कि द मेडियन मिनिमाइज़्स द योग ऑफ एब्सोल्यूट डिविएशन ( नॉर्म)${L}_{1}$ ।

ऑपरेटर का नाम जानने के बाद, यह एक वैकल्पिक 19 बाइट समाधान है:

Norm[#-Median@#,1]&

Comments

यादृच्छिक टिप्पणी: Medianकुछ गूढ़ भाषाओं के लिए थोड़ा कठिन है।

— user202729

थोड़ा इधर-उधर देखते हुए, "कंप्यूट माध्यिका" चुनौती में गूढ़ भाषा में एकमात्र प्रस्तुत करना डब्ल्यूडब्ल्यूई के ब्रेन-फ्लैक एक है ।

— user202729

Answer 2

जावास्क्रिप्ट (Node.js) , 50 48 बाइट्स

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

Comments

अच्छा है! आप के साथ 2 बाइट्स बचा सकते हैं a=>a.sort((x,y)=>x-y).map(n=>r+=a.pop()-n,r=0)|r।

— अरनौलद

Answer 3

05AB1E , 4 बाइट्स

ÅmαO

इसे ऑनलाइन आज़माएं!

व्याख्या

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

Comments

माध्य! यही वह शब्द है जिसकी मुझे तलाश थी! ZL€αOWमेरा प्रयास था ।_

— मैजिक ऑक्टोपस Urn

Answer 4

पर्ल 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

Comments

आप X-एक बाइट को बचाने के लिए ऑपरेंड स्वैप कर सकते हैं ।

— nwellnhof

Answer 5

जाप, 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

Answer 6

जावास्क्रिप्ट (ईएस 6), 60 56 55 बाइट्स

@ बस्ती के लिए 1 बाइट का धन्यवाद सहेजा गया

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

इसे ऑनलाइन आज़माएं!

कैसे?

जब तक कि कुछ ट्रिक नहीं है जो मुझे याद आ रही है, जेएस में माध्यिका की गणना करने पर वह लम्बी हो जाती है। डिफ़ॉल्ट लेक्सिकोग्राफ़िक सॉर्ट को रोकने के लिए आवश्यक कॉलबैक की वजह से संभवतः लगभग 65 बाइट्स और लगभग sort()लंबा Math.abs():

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

इसके बजाय, हम मूल मान में सभी मानों को बराबर मान के रूप में आज़माते हैं ।

Comments

rपहले के भीतर घोषित करके -2 बाइट्सmap ।

— झबरा

Answer 7

हास्केल , 34 बाइट्स

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

इसे ऑनलाइन आज़माएं!

औसत तत्व के रूप में सूची में प्रत्येक तत्व का परीक्षण करने और सबसे छोटे परिणाम लेने के लिए सभी तत्वों की औसत दूरी प्राप्त करता है।

Answer 8

जेली , 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.

Answer 9

पायथन 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()उत्पादित ऊपरी सीमा को अनदेखा करती है। ऐसा प्रतीत हो सकता है कि सूची को सही तरीके से कटा हुआ होने के लिए बहुत देर हो गई थी, लेकिन लगता है कि सूची को कटा हुआ करने के लिए "तर्क" में ताला लगाने से पहले अजगर तर्क का मूल्यांकन करता है।

---

पायथन 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इसका कोई असर नहीं होता है। स्लाइस l[None:1]वही है l[:1]क्योंकि Noneस्लाइस में s अनदेखा है।

---

पायथन , 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अप्रयुक्त टुकड़ा अंत बहस में अटक हो सकता है।

Answer 10

एपीएल (डायलॉग), 12 बाइट्स

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

समतुल्य के रूप में प्रत्येक संख्या का परीक्षण करके बलों को भंग करें। निश्चित नहीं है कि टैसीट छोटा है, लेकिन मैं इसका पता नहीं लगा सकता।

TIO

Answer 11

टीआई-बेसिक, 18 6 बाइट्स

sum(abs(Ans-median(Ans

मिशा लावरोव से -12 बाइट्स (मैंने थोड़ी देर में टीआई-बेसिक का उपयोग नहीं किया है और मैं भूल गया कि यह सूचियां ऐसा कर सकती हैं)

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

Comments

sum(abs(Ans-median(Ansभी काम करता है। (और "TI-84 Plus CE" अत्यधिक विशिष्ट लगता है; यह कम से कम 83-सीरीज़ कैलकुलेटर पर काम करेगा, और शायद 73 और 82 पर भी।)

— मिशा लावरोव

Answer 12

रोड़ा , 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 */
}

Answer 13

आर , 29 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 14

अटैची , 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

Answer 15

जे , 15 बाइट्स

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

मूलतः शैगी के जाप समाधान के समान।

इसे ऑनलाइन आज़माएं!

यह काम किस प्रकार करता है?

|@-/~"{- सभी दूसरों के लिए प्रत्येक संख्या /~के पूर्ण अंतर |@-की एक तालिका बनाता है"{

   |@-/~"{ 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

Answer 16

चारकोल , 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

Comments

यह 11 बाइट्स के लिए काम करना चाहिए ।

— अरनुलद

@ अरनुल अह, बेशक, विषम लंबाई सरणियों के लिए मंझला हमेशा सरणी का एक सदस्य होता है, और यहां तक ​​कि लंबाई सरणियों के लिए, मध्य दो के बीच और सहित सभी मानों के लिए योग समान होता है। धन्यवाद!

— नील

Answer 17

दृश्य सी #, 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);

इसे ऑनलाइन आज़माएं!

Comments

यह कोड TIO पर [1,10,100] के लिए विफल हो रहा है। यह 99 के बजाय 126 लौट रहा है।

— मेकर्त

Answer 18

सी (जीसीसी), 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
}

Answer 19

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)

Answer 20

PHP, 69 बाइट्स

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

अनाम फ़ंक्शन। इसे ऑनलाइन आज़माएं ।

Comments

@ प्रॉग्रोक Input: *) A non-empty array a of integers *) Optionally, the length of a।

— टाइटस

@Progrock एक पोस्ट-डिक्रीमेंट समान चाल करता है। लेकिन संकेत के लिए धन्यवाद।

— टाइटस

Answer 21

जावास्क्रिप्ट (Node.js) , 52 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 22

जावा (JDK), 112 बाइट्स

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

Comments

PPCG में आपका स्वागत है! दुर्भाग्य से, इनपुट के लिए आपका समाधान विफल रहता है [1,1,4](रिटर्न 4, लेकिन उत्तर 3 है)।

— Delfad0r

एक नोट जो आप औसत के बजाय सरणी के अर्थ का उपयोग करते हुए प्रतीत होता है

— जो किंग

Answer 23

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

ऑनलाइन प्रयास करें

Comments

ध्यान दें कि पूर्व घोषित चर के माध्यम से इनपुट की अनुमति नहीं है। इसके अतिरिक्त, आप अपने चर नामों को थोड़ा छोटा कर सकते हैं

— जो किंग

यकीन है, मैं इसे शीघ्र ही करूँगा।

— सैयद हमजा हसन