Halte diese Herausforderung kurz.

Sie erhalten 4 Zahlen: p1, p2, p3 und p4.

Die magische Summe der Zahlen ist wie folgt definiert:

magic_sum = |p1 - p2| + |p2 - p3| + |p3 - p4| + |p4 - p1|

Sie dürfen nur einen der obigen ganzzahligen Werte (p1, p2, p3 oder p4) ändern. Sie müssen den Wert so ändern, dass die magische Summe der Werte ihren Mindestwert erreicht.

Beispielsweise:

p1, p2, p3, p4 = 17, -6, 15, 33. Der Wert der magischen Summe beträgt in diesem Fall 78.

Sie können hier -6 in 16 ändern, und der Wert der magischen Summe wird zu 36, was dem minimal erreichbaren Wert entspricht.

Denken Sie daran, dass Zahlen positive oder negative ganze Zahlen sein können.

Das ist Code-Golf, also gewinnen die wenigsten Byte im Code. Brownie-Punkte für die Verwendung einer praktischen Sprache gegenüber einer Freizeitsprache. Möge der 4. mit dir sein.

Wiederholen:

Probe 1

Eingang 1

17 -6 15 33

Ausgang 1

36

Erklärung 1

Die -6 kann durch 16 ersetzt werden und das gibt uns die minimal erreichbare magische Summe, die möglich ist.

Probe 2

Eingang 2

10 10 10 10

Ausgang 2

0 or 2

beides ist akzeptabel

Erklärung 2

Die minimal erreichbare magische Summe ist 0, da die minimale Summe von 4 positiven ganzen Zahlen 0 ist. Wenn eine Zahl geändert werden muss, kann eine der 10 in eine 9 geändert werden und somit die Ausgabe 2 ergeben.

Probe 3

Eingang 3

1 2 3 4

Ausgang 3

4

Erklärung 3

Die Eingabe selbst ergibt 6 als magische Summe. Durch Ändern der 4 in 1 wird die minimale magische Summe erreicht, die 4 ist.

Gelee , 6 Bytes

ṢŒœIṂḤ

Probieren Sie es online!

Ein Port meiner Python-Antwort .

     (input)        [17, -6, 15, 33]
Ṣ    sort           [-6, 15, 17, 33]
Œœ   odd-even elts  [[-6, 17], [15, 33]]
I    increments     [23, 18]
M    minimum        18
Ḥ    double         36 

Python 2 , 44 Bytes

a,b,c,d=sorted(input())
print min(c-a,d-b)*2

Probieren Sie es online!

Sortiert die Eingabe a,b,c,d,in aufsteigender Reihenfolge, nimmt das kleinere von c-aund d-bund verdoppelt es. Warum funktioniert das?

Beachten Sie zunächst, dass es beim Ändern eines Elements zur Maximierung auf die zyklische Gesamtsumme der Abstände optimal (oder für das Optimum gebunden) ist, es so zu ändern, dass es einem Nachbarn entspricht, z 17, -6, 15, 33 -> 17, 17, 15, 33. Das liegt daran, dass die neue Gesamtentfernung zu den linken und rechten zyklischen Nachbarn mindestens der Abstand zwischen diesen Nachbarn ist. Daher ist es das Beste, diese gleich zu machen.

Wenn Sie nun eine von zwei benachbarten Kopien einer Zahl löschen, erhalten Sie dieselbe zyklische Summe von Entfernungen. Im Beispiel ist dies die 17, 15, 33Angabe von Entfernungen 2 + 18 + 16. Anstatt also eine der vier Zahlen zu ersetzen, ist es gleichbedeutend damit, sie zu löschen und drei Zahlen zu belassen und die Summe ihrer zyklischen Abstände zu verwenden.

Beachten Sie, dass bei 3 Zahlen der größte Abstand die Summe der beiden kleineren ist. Dies liegt daran, wenn wir die Zahlen sortieren a ≤ b ≤ c, um dann zu haben |a - c| = |a - b| + |b - c|. Mit anderen Worten, wir bewegen uns zweimal zwischen der größten und der kleinsten Zahl, wobei wir die mittlere Zahl einmal als Boxenstopp verwenden. Die Summe der drei Abstände ist also nur doppelt so groß wie der Abstand zwischen Minimum und Maximum (c-a)*2.

Die Frage ist also, welche Zahl wir löschen, um den kleinsten Abstand zwischen dem Minimum und dem Maximum der drei verbleibenden Zahlen zu erhalten. Es ist klar, dass wir entweder die kleinste oder die größte Zahl löschen. Wenn Sie sie a, b, c, din sortierter Reihenfolge aufrufen, aBlätter löschen d - bund dBlätter löschen c - a, ist das Endergebnis doppelt so hoch, je nachdem, welcher Wert kleiner ist.

R , 66 33 Bytes

function(x)2*min(diff(sort(x),2))

Probieren Sie es online!

Viel kürzer mit dem Algorithmus von xnor (lies ihre Erklärung und stimme ihrem Beitrag zu!).

Alte Version:

R , 66 Bytes

function(x,m=matrix(x,3,4))min(colSums(abs(diff(rbind(m,m[1,])))))

Probieren Sie es online!

Nimmt die Eingabe als einen Vektor von 4 ganzen Zahlen.

$p_2$$p_2$$p_1\leq p_2\leq p_3$$|p_1-p_2|+|p_2-p_3|$$p_2=p_1$.

Es gibt 4 Möglichkeiten, die zu ändernde Nummer auszuwählen. für jedes von diesen müssen wir nur die Summe von 3 absoluten Differenzen berechnen.

$3\times4$rbind

Jelly , 11 bis 10 Bytes

I;SASƲ$-ƤṂ

Probieren Sie es online!

Ein monadischer Link, der eine Liste mit ganzen Zahlen als Eingabe verwendet. Sollte bei beliebiger Listengröße funktionieren. Arbeitet auf der Grundlage, dass die minimale Summe erhalten werden kann, indem jede Zahl aus der Liste entfernt, die magische Summe berechnet und das Minimum genommen wird.

Gelee , 8 Bytes

ṁ-Ƥ⁸IA§Ṃ

Ein monadischer Link, der eine Liste von Ganzzahlen * akzeptiert, die eine Ganzzahl ergibt

_{* kann eine beliebige Zahl sein, solange es mehr als 1 gibt; Verwenden der gleichen Zauberformel, um die Unterschiede der Nachbarn zu summieren.}

Probieren Sie es online!

Wie?

ṁ-Ƥ⁸IA§Ṃ - Link: list of integers, X       e.g. [17,-6,15,33]
 -Ƥ      - for overlapping "outfixes" of length length(X)-1:
         -                                      [[-6,15,33],[17,15,33],[17,-6,33],[17,-6,15]]
ṁ  ⁸     -   mould like X                       [[-6,15,33,-6],[17,15,33,17],[17,-6,33,17],[17,-6,15,17]]
    I    - incremental differences              [[21,18,-39],[-2,18,-16],[-23,39,-16],[-23,21,2]]
     A   - absolute (vectorises)                [[21,18,39],[2,18,16],[23,39,16],[23,21,2]]
      §  - sums                                 [78,36,78,46]
       Ṃ - minimum                              36

Japt -Q , 11 Bytes

ñÍó ®r- ÑÃn

Verwendet den @ xnor-Algorithmus, der mir 4 Bytes erspart hat.

5 Bytes gespart dank @Shaggy

Versuch es

J , ^{24, 20, 18,} 17 Bytes

alternative Version unter Verwendung des xnor-Algorithmus:

2*[:<./2 2-/@$\:~

Wie

Das Zweifache 2 *der min [:<./der 2. Zeile wird von der ersten Zeile [:-/der 2x2-Matrix subtrahiert, die durch 2 2$die nach unten sortierte Formung der Eingabe gebildet wird\:~

Probieren Sie es online!

ursprüngliche Antwort: J , 24 Bytes

[:<./1(1#.2|@-/\],{.)\.]

Probieren Sie es online!

Mit Nick Kennedys Idee.

• 1(...)\.] wende das Verb in Parens auf alle Outfixes der Länge 1 an (ein Outfix der Länge n ist eine Liste mit n entfernten zusammenhängenden Elementen, so dass jede mögliche Liste mit 1 entfernten Ulme erzeugt wird)
• (1 #. 2 |@-/\ ] , {.)Dies berechnet die magische Summe, indem die erste Ulme an die Eingabe ] , {.angehängt und die abs-Differenz |@-/auf Infixe der Länge 2 2 ...\angewendet und das Ergebnis summiert wird 1 #..
• [:<./ gibt die min

05AB1E , 11 7 Bytes

Port von @xnors Gelee Antwort .
-4 Bytes dank @Emigna und @Grimy .

{2ô`αß·

Probieren Sie es online aus.

7 Bytes Alternative , die nur in der alten Version von 05AB1E arbeitet (wäre erforderlich , €bevor die ¥in der neuen Version):

{2ôø¥W·

Probieren Sie es online aus.

Erläuterung:

{        # Sort the (implicit) input-list
         #  i.e. [17,-6,15,33] → [-6,15,17,33]
 2ô      # Split this list into parts of size 2
         #  → [[-6,15],[17,33]]
   `     # Push both separated to the stack
    α    # And take their absolute differences
         #  → [23,18]
     ß   # Pop and push the minimum
         #  → 18
      ·  # Double it (and output implicitly as result)
         #  → 36

{        # Sort the (implicit) input-list
         #  i.e. [17,-6,15,33] → [-6,15,17,33]
 2ô      # Split this list into parts of size 2
         #  → [[-6,15],[17,33]]
   ø     # Zip/transpose, swapping rows/columns
         #  → [[-6,17],[15,33]]
    ¥    # Get the deltas/forward differences of the inner lists
         #  → [[23],[18]]
     W   # Get the flattened minimum (without popping)
         #  → 18
      ·  # Double it (and output implicitly as result)
         #  → 36

C ++ (gcc)

Volles Programm: 138 Bytes

#include<iostream>
#include<regex>
using namespace std;int main(){int a[4];for(int&b:a)cin>>b;sort(a,a+4);cout<<min(a[2]-*a,a[3]-a[1])*2;}

Probieren Sie es online!

Kernfunktion: 84 Bytes

#include<regex>
int m(int*a){std::sort(a,a+4);return std::min(a[2]-*a,a[3]-a[1])*2;}

Probieren Sie es online!

Verwenden Sie auch den Algorithmus xnor , der in seinem Beitrag zu Python 2 erläutert wurde.

Holzkohle , 20 Bytes

Ｉ⌊ＥＥθΦθ⁻κμΣＥι↔⁻λ§ι⊕μ

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Es stellte sich heraus, dass ich die Idee von @ NickKennedy verwende. Erläuterung:

   Ｅθ                   Map over input array
     Φθ                 Filter over input array where
       ⁻κμ              Outer and inner indices differ
  Ｅ                     Map over resulting list of lists
           Ｅι           Map over remaining values in list
                §ι⊕μ    Get the next value in the list
             ↔⁻λ        Compute the absolute difference with the current value
          Σ             Take the sum of absolute differences
 ⌊                      Take the minimum sum
Ｉ                       Cast to string and implicitly print

JavaScript (ES6), 51 Byte

Mit der viel clevereren Methode von xnor :

a=>([a,b,c,d]=a.sort((a,b)=>a-b),b+c<a+d?c-a:d-b)*2

Probieren Sie es online!

Ursprüngliche Antwort, 96 Bytes

Nimmt die Eingabe als Array von 4 ganzen Zahlen. Wahrscheinlich definitiv nicht der kürzeste Weg.

a=>a.map(m=x=>a.map((y,i)=>a[m=a.map(v=>s+=Math.abs(p-(p=v)),a[i]=x,p=a[3],s=0)|m<s?m:s,i]=y))|m

Probieren Sie es online!

Wolfram Language (Mathematica) , 29 Byte

Ein Port von @ xnors Algorithmus

2{#3-#}~Min~{#4-#2}&@@Sort@#&

Probieren Sie es online!

Java 8 , 235 Bytes

Ein Port von @ xnors Python-Antwort und -Algorithmus

import java.util.*;interface M{static void main(String[]A){Scanner I=new Scanner(System.in);int a[]={0,0,0,0};for(int i=0;i<4;a[i++]=I.nextInt());java.util.Arrays.sort(a);System.out.print(2*(a[2]-a[0]>a[3]-a[1]?a[3]-a[1]:a[2]-a[0]));}}

Probieren Sie es online!

Java 10 , nicht bewiesen, 222 Bytes

Mit Java 10 sollte es mir möglich sein, die linke Seite der Scanner-Deklaration durch zu ersetzen var, obwohl ich sie nicht online kompilieren konnte und sie daher nur als Trivia hinzufügen kann. Es tut uns leid.

interface M{static void main(String[]A){var I=new java.util.Scanner(System.in);int a[]={0,0,0,0};for(int i=3;i<4;a[i++]=I.nextInt());java.util.Arrays.sort(a);System.out.print(2*(a[2]-a[0]>a[3]-a[1]?a[3]-a[1]:a[2]-a[0]));}}