Parece que cualquier modificación simple de deltas usando una función consistente casi siempre se puede hacer de otra manera más corta , Dennis . Por lo tanto, la única solución que puedo imaginar para hacer esto más difícil es introducir algún tipo de función inconsistente.

Clasificación.

Su tarea es tomar una matriz de enteros, ordenar sus deltas y volver a compilar eso para obtener la nueva matriz de enteros.

P.EJ.

Para la entrada:

1  5 -3  2  9

Obtenga los siguientes Deltas:

  4 -8  5  7

Luego, ordena estos Deltas, cediendo:

 -8  4  5  7

Y vuelva a aplicarlos, lo que da:

1 -7 -3  2  9

De entrada y salida

Se le dará una lista / array / table / tuple / stack / etc. de enteros con signo como entrada a través de cualquier método de entrada estándar.

Debe generar los datos modificados una vez más en cualquier forma aceptable, siguiendo el método de clasificación delta anterior.

Recibirá N entradas 0 < N < 10donde cada número cae dentro del rango-1000 < X < 1000

Casos de prueba

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

Notas

• Como se indicó anteriormente, siempre recibirá al menos 1 entrada y no más de 9.
• El primer y último número de su salida siempre coincidirá con el de la entrada.
• Solo se acepta la entrada de salida estándar
• Se aplican lagunas estándar
• Este es el código de golf , por lo que gana el conteo de bytes más bajo.
• ¡Que te diviertas!

Jalea , 7 bytes

IṢ;@Ḣ+\

Pruébalo en línea!

Cómo funciona

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

Pruébalo en línea!

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@#]&

Función pura que toma una lista de (cualquier cosa) como entrada y devuelve una lista. FoldList[Pluscomienza con un número (en este caso, #&@@#el primer elemento de la entrada) y agrega repetidamente elementos de la lista autoexplicativa Sort@Differences@#. Esto imita el comportamiento del incorporado Accumulate, pero el primer número necesitaría anteponerse a la lista de diferencias a mano, lo que aumenta el recuento de bytes (hasta donde puedo decir).

05AB1E , 9 bytes

-4 gracias a Emigna

¬=s¥{vy+=

Pruébalo en línea!

¬         # 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)

Descompostura:

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 bytes

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

En JavaScript resulta ser más golfista calcular los deltas inversos de una matriz . Estos se ordenan en orden descendente y se restan acumulativamente del primer elemento.

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

Guardado 6 bytes al usar lambda. Gracias a los ovs!

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

Pruébalo en línea!

Rompiendo el código,

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

¡Feliz codificación!

JavaScript (ES6), 93 bytes

(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

Pruébalo en línea!

Pyth, 11 bytes

.u+NYS.+QhQ

Esto solo hace lo obvio descrito en la declaración.

Pruébalo en línea

      .+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

Sugerencias para más golf de bienvenida.

Julia 0.5 , 30 bytes

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

Pruébalo en línea!

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],_;

Corre así:

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_

Explicación

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 con numpy, 67 56 bytes

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

Deje que numpy calcule los deltas, ordénelos, anteponga el primer elemento y deje que numpy calcule las sumas acumulativas. ¿Bastante barato?

Perl 6 , 31 bytes

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

Intentalo

Expandido:

{
  [\+]            # 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
}

Lote, 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 no se ordena numéricamente, por lo que sesgo todas las diferencias por 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 %)%)))

Un día voy a hacer el lenguaje Cljr que tiene nombres de funciones más cortos que Clojure.