Es scheint, dass jede einfache Änderung von Deltas unter Verwendung einer konsistenten Funktion fast immer auf eine andere kürzere Weise durchgeführt werden kann , Dennis . Die einzige Lösung, die ich mir vorstellen kann, um dies zu erschweren, ist die Einführung einer inkonsistenten Funktion.

Sortierung.

Ihre Aufgabe ist es, ein Array von Ganzzahlen zu nehmen, ihre Deltas zu sortieren und diese neu zu kompilieren, um das neue Array von Ganzzahlen zu erhalten.

Z.B.

Für die Eingabe:

1  5 -3  2  9

Holen Sie sich die folgenden Deltas:

  4 -8  5  7

Sortieren Sie dann diese Deltas und ergeben Sie:

 -8  4  5  7

Und wende sie erneut an, was ergibt:

1 -7 -3  2  9

Input-Output

Sie erhalten eine Liste / Array / Tabelle / Tupel / Stapel / etc. von vorzeichenbehafteten Ganzzahlen als Eingabe über eine beliebige Standardeingabemethode.

Sie müssen die geänderten Daten erneut in einer akzeptablen Form ausgeben, und zwar gemäß der obigen Delta-Sortiermethode.

Sie erhalten N Eingaben, bei 0 < N < 10denen jede Zahl in den Bereich fällt-1000 < X < 1000

Testfälle

1 5 -3 2 9   -> 1 -7 -3 2 9
-5 -1 -6 5 8 -> -5 -10 -7 -3 8
-8 1 -7 1 1  -> -8 -16 -16 -8 1
8 -9 3 0 -2  -> 8 -9 -12 -14 -2
-5 -2 -5 5 0 -> -5 -10 -13 -10 0
-1 9 -1 -7 9 -> -1 -11 -17 -7 9

Anmerkungen

• Wie oben angegeben, erhalten Sie immer mindestens 1 Eingabe und nicht mehr als 9.
• Die erste und letzte Nummer Ihrer Ausgabe stimmen immer mit der der Eingabe überein.
• Es wird nur die Standardeingabe akzeptiert
• Es gelten Standardlücken
• Dies ist Code-Golf , also gewinnt die niedrigste Byteanzahl!
• Habe Spaß!

Gelee , 7 Bytes

IṢ;@Ḣ+\

Probieren Sie es online aus!

Wie es funktioniert

IṢ;@Ḣ+\  Main link. Argument: A (array)

I        Increments; compute the deltas.
 Ṣ       Sort them.
    Ḣ    Head; pop and yield the first element of A.
  ;@     Concatenate with swapped arguments.
     +\  Take the cumulative sum.

MATL , 8 Bytes

1)GdShYs

Probieren Sie es online aus!

1)   % Implicit input. Get its first entry
G    % Push input again
d    % Differences
S    % Sort
h    % Concatenate
Ys   % Cumulative sum. Implicit display

Mathematica, 40 Bytes

FoldList[Plus,#&@@#,Sort@Differences@#]&

Reine Funktion, die eine Liste von (irgendetwas) als Eingabe nimmt und eine Liste zurückgibt. FoldList[Plusbeginnt mit einer Zahl (in diesem Fall #&@@#dem ersten Element der Eingabe) und fügt wiederholt Elemente der selbsterklärenden Liste hinzu Sort@Differences@#. Dies ahmt das Verhalten des eingebauten AccumulateGeräts nach, aber die erste Zahl müsste der Liste der Unterschiede von Hand vorangestellt werden, wodurch die Anzahl der Bytes höher wird (soweit ich das beurteilen kann).

05AB1E , 9 Bytes

-4 danke an Emigna

¬=s¥{vy+=

Probieren Sie es online aus!

¬         # Get the head
 =        # Print
  s¥{     # Get sorted Deltas
     vy   # For each
       += # Add to the previous value and print

Python 2, 92 Bytes

l=input();p=0;d=[]
r=l[0],
for e in l:d+=e-p,;p=e
for e in sorted(d[1:]):r+=r[-1]+e,
print r

Haskell, 59 Bytes

import Data.List
f l@(a:b)=scanl1(+)$a:(sort$zipWith(-)b l)

Nervenzusammenbruch:

f l@(a:b) =           --we create a function f that takes as input a list l with head a and tail b
zipWith(-)b l        --we make a new list with the deltas
sort$                    --sort it
a:                          --prepend a to the list
scanl1(+)$          --create a new list starting with a and adding the deltas to it cumulatively

JavaScript (ES6), 68 Byte

([p,...a])=>[s=p,...a.map(e=>p-(p=e)).sort((a,b)=>b-a).map(e=>s-=e)]

In JavaScript erweist es sich als schwieriger, die inversen Deltas eines Arrays zu berechnen . Diese werden dann in absteigender Reihenfolge sortiert und kumulativ vom ersten Element abgezogen.

Python 2 ,

90 Bytes

x=input()
print[sum(sorted(map(int.__sub__,x[1:],x[:-1]))[:i])+x[0]for i in range(len(x))]

84 Bytes

6 Bytes bei Verwendung von Lambda gespart. Danke an ovs!

lambda x:[sum(sorted(map(int.__sub__,x[1:],x[:-1]))[:i])+x[0]for i in range(len(x))]

Probieren Sie es online aus!

Code aufschlüsseln,

>>> x
[1, 5, -3, 2, 9]
>>> map(int.__sub__,x[1:],x[:-1]) #delta
[4, -8, 5, 7]
>>> sorted(map(int.__sub__,x[1:],x[:-1])) #sorted result
[-8, 4, 5, 7]
>>> [sorted(map(int.__sub__,x[1:],x[:-1]))[:i]for i in range(len(x))]
[[], [-8], [-8, 4], [-8, 4, 5], [-8, 4, 5, 7]]
>>> [sum(sorted(map(int.__sub__,x[1:],x[:-1]))[:i])+x[0]for i in range(len(x))]
[1, -7, -3, 2, 9]

Viel Spaß beim Codieren!

JavaScript (ES6), 93 Byte

(p,M=[p[0]])=>p.map((a,b)=>p[b+1]-a).sort((a,b)=>a-b).map((a,b)=>M=[...M,M[b]+a])[p.length-2]

Python 2 , 97 Bytes

p=input()
d=[p[i+1]-p[i] for i in range(len(p)-1)]
o=p[:1]
for n in sorted(d):o+=o[-1]+n,
print o

Probieren Sie es online aus!

Pyth, 11 Bytes

.u+NYS.+QhQ

Dies macht nur das Offensichtliche, was in der Aussage beschrieben ist.

Probieren Sie es online aus

      .+Q    Take the deltas of the input
     S       sort it
.u           Cumulative reduce
  +NY        using addition
         hQ  starting with the first element of the input

Vorschläge für weiteres Golfen willkommen.

Julia 0,5 , 30 Bytes

!x=[x[];x|>diff|>sort]|>cumsum

Probieren Sie es online aus!

PHP, 89 Bytes

for($a=$argv;n|$i=$a[++$x+1];)$d[]=$i-$a[$x];for(sort($d);$x-$y++;)echo$a[1]+=$d[$y-2],_;

Laufen Sie so:

php -nr 'for($a=$argv;n|$i=$a[++$x+1];)$d[]=$i-$a[$x];for(sort($d);$x-$y++;)echo$a[1]+=$d[$y-2],",";' 1  5 -3  2  9;echo
> 1_-7_-3_2_9_

Erläuterung

for(
  $a=$argv;          # Set input to $a.
  n | $i=$a[++$x+1]; # Iterate over input.
)
  $d[] = $i-$a[$x];  # Add an item to array $d, with the difference between
                       the current and previous item.

for(
  sort($d);          # Sort the delta array.
  $x-$y++;           # Loop as many times as the previous loop.
)
  echo
    $a[1]+=$d[$y-2], # Print the first input item with the delta applied
                     # cumulatively. First iteration takes $d[-1], which
                     # is unset, so results in 0.
    _;               # Print underscore as separator.

Python 2 mit Numpy, 67 56 Bytes

from numpy import*
lambda l:cumsum(l[:1]+sorted(diff(l)))

Lassen Sie numpy die Deltas berechnen, sortieren, das erste Element voranstellen und numpy die kumulierten Summen berechnen. Ziemlich billig?

Perl 6 , 31 Bytes

{[\+] @_[0],|sort @_[1..*]Z-@_}

Versuch es

Erweitert:

{
  [\+]            # triangle produce values using &infix<+>
    @_[0],        # starting with the first argument
    |             # slip the following into this list
      sort        # sort the following

         # generate the list of deltas

         @_[1..*] # the arguments starting with the second one
         Z[-]     # zipped using &infix:<->
         @_       # the arguments
}

Stapel, 197 Bytes

@set n=%1
@set s=
:l
@set/ad=5000+%2-%1
@set s=%s% %d%
@shift
@if not "%2"=="" goto l
@echo %n%
@for /f %%a in ('"(for %%b in (%s%)do @echo %%b)|sort"') do @set/an+=%%a-5000&call echo %%n%%

sort sortiert nicht numerisch, daher verzerre ich alle Unterschiede um 5000.

Bash + Sort, 102 Bytes

echo $1
n=$1
shift
for e in $*
do
echo $((e-n))
n=$e
done|sort -n|while read e
do
echo $((n+=e))
done

sh + sort + expr, 106 Bytes

echo $1
n=$1
shift
for e in $*
do
expr $e - $n
n=$e
done|sort -n|while read e
do
n="$n + $e"
expr $n
done

Clojure, 46 Bytes

#(reductions +(first %)(sort(map -(rest %)%)))

Eines Tages werde ich eine Cljr-Sprache erstellen, die kürzere Funktionsnamen als Clojure hat.