La lista de diferencias de una lista de enteros es la lista de diferencias de miembros consecutivos.

Por ejemplo, la lista de diferencias de

1, 3, 2 ,4

es

2, -1, 2

Su tarea es tomar como entrada una lista de diferencias y mostrar cómo se vería la lista de diferencias si se ordenara la lista original.

Por ejemplo la lista de diferencias

2, 1, -2, -1

Podría representar una lista

2 4 5 3 2

Que cuando se ordena es

2 2 3 4 5

Que tiene una lista de diferencias de

0 1 1 1

Este es el código de golf, por lo que las respuestas se puntuarán en bytes, siendo mejores menos bytes.

05AB1E , 4 bytes

.¥{¥

Pruébalo en línea!

Explicación

.¥{¥
.¥   # Undelta the input list
  {  # Sort it
   ¥ # And get the deltas

Python 3 con Numpy , 56 54 53 bytes

2 bytes de descuento gracias a @Artyer (Numpy's en sortlugar de estándar sorted). 1 byte apagado gracias a @notjagan (mudarse 0a cumsum)

lambda x:diff(sort(cumsum([0]+x)))
from numpy import*

El código define una función anónima que ingresa una lista o una matriz Numpy y genera una matriz Numpy.

Pruébalo en línea!

Mathematica, 40 bytes

Differences@Sort@Accumulate@Join[{1},#]&

Jalea , 6 bytes

0;+\ṢI

Pruébalo en línea!

Casco , 4 bytes

Ẋ-O∫

Pruébalo en línea!

Explicación

      -- implicit input, e.g                               [2,1,-2,-1]
   ∫  -- cumulative sum                                    [0,2,3,1,0]
  O   -- sort                                              [0,0,1,2,3]
Ẋ     -- apply function to all adjacent pairs in the list  [(0,0),(0,1),(1,2),(2,3)]
 -    --   subtract                                        [0,1,1,1]

Pyth , 9 bytes

-1 byte gracias a @EriktheOutgolfer .

.+S+0sM._

Banco de pruebas.

Pyth , 10 bytes

.+S.u+YNQ0

Pruébalo en línea! o Pruebe más casos de prueba .

JavaScript (ES6), 57 56 bytes

Guardado 1 byte gracias a @ETHproductions

a=>a.map(n=>t-=n,p=t=0).sort((a,b)=>b-a).map(n=>p-(p=n))

Manifestación

let f =

a=>a.map(n=>t-=n,p=t=0).sort((a,b)=>b-a).map(n=>p-(p=n))

console.log(JSON.stringify(f([2, 1, -2, -1])))

Java 8, 123 bytes

La solución estándar: entrada de suma acumulativa, ordenar, luego diff. No hay trucos sustanciales de implementación tampoco.

l->{int s=l.length,d[]=new int[s+1],i=0;while(i<s)d[i+1]=d[i]+l[i++];for(java.util.Arrays.sort(d);i-->0;)l[i]=d[i+1]-d[i];}

Fundido a Consumer<int[]>. La salida es entrada mutada.

Pruébalo en línea

Lambda sin golf

l -> {
    int
        s = l.length,
        d[] = new int[s + 1],
        i = 0
    ;
    while (i < s)
        d[i + 1] = d[i] + l[i++];
    for (java.util.Arrays.sort(d); i-- > 0; )
        l[i] = d[i + 1] - d[i];
}

Expresiones de gratitud

• -3 bytes gracias a Olivier Grégoire , maestro de la autoincrementación impía
• -1 byte gracias a Nevay

Brachylog , 15 bytes

a₀ᶠ+ᵐ,0o{s₂↔-}ᶠ

Pruébalo en línea!

R , 31 32 bytes

-4 bytes gracias a @ user2390246 por diffinv

+5 bytes de Jarko para cat

cat(diff(sort(diffinv(scan()))))

Lee desde stdin, escribe en stdout. diffinves un inverso de diffun valor inicial dado (0 por defecto). Como está diffeditado nuevamente, no importa cuál sea ese valor.

Como señaló Jarko Dubbeldam, necesitaba generar correctamente el resultado, a un costo de cinco bytes. Ay.

Pruébalo en línea!

Python 2 , 83 bytes

l,r=input(),[1]
for i in l:r+=[r[-1]+i]
r.sort()
print[b-a for a,b in zip(r,r[1:])]

Pruébalo en línea!

Solución horrible

Perl 6 , 46 bytes

{[\+](0,|@_).sort.rotor(2=>-1).flat.map(*R-*)}

Intentalo

Expandido:

{  # bare block lambda with implicit signature :(*@_)

  [\+](         # triangle reduce using &infix:«+»
    0,          # start with 0
    |@_         # Slip in the arguments from the outer block
  )             #                  (0, 2, 3, 1, 0)

  .sort         # sort the results (0,0,1,2,3)
  .rotor(2=>-1) # group in twos    ((0,0),(0,1),(1,2),(2,3))
  .flat         # flatten          (0,0,0,1,1,2,2,3)
  .map(*R-*)    # grab 2 values at a time, and subtract first from second
                # (0, 1, 1, 1)
}

Haskell , 74 bytes

import Data.List
g=sort.scanl(+)0
h l|k<-g l=map(\(x,y)->x-y)$zip(tail$k)k

Pruébalo en línea!

Sencillo.

TI-Basic (TI-84 Plus CE), 23 bytes

Prompt X
augment({0},cumSum(LX→X
SortA(LX
ΔList(LX

Solicita la entrada del usuario. La lista debe ser ingresada con un inicio {, con números separados por ,, y con un final opcional }.

TI-Basic es un lenguaje tokenizado ; ΔList(y cumSum(son tokens de dos bytes, todos los demás tokens utilizados son de un byte cada uno.

Ejemplo de ejecución (con NAMEel nombre del programa y {4,-2,7,-4,0}la entrada):

prgmNAME
X=?{4,-2,7,-4,0}
               {2 2 1 0 4}

Explicación:

Prompt X                  # 3 bytes, get list input, store in LX
augment({0},cumSum(LX→X   # 12 bytes, 
          # store the list ({0} prepended to the cumulative sum of LX) to LX
SortA(LX                  # 4 bytes, sort LX ascending
ΔList(LX                  # 4 bytes, implicitly print the difference list of LX

C ++ (gcc) , 136 bytes

Como lambda genérico sin nombre, suponiendo que la entrada sea similar std::listy que regrese a través del parámetro de referencia.

[](auto&L){auto r=L.begin(),l=L.insert(r,0);while(r!=L.end())*r+++=*l++;for(L.sort(),l=r=--L.end();--l!=L.begin();*r---=*l);L.erase(l);}

Pruébalo en línea!

Sin golf:

[](auto&L){
 auto r=L.begin(),
      l=L.insert(r,0); //adds a zero right in front
 while(r!=L.end())
   *r++ += *l++;       //sum left to right
 for(
  L.sort(),            //sorting invalidates the iterators
  l=r=--L.end();       //so, reinit
  --l!=L.begin();      //decrement l beforehand 
  *r-- -= *l           //diff right to left
 );
 L.erase(l);           //l==L.begin(), so this removes the temporary 0
}

Pyth, 8 bytes

.+S+M.uP

Demostración

.+S+M.uP
.+S+M.uPNQ    Implicit variables
     .u  Q    Apply the following function to the input repeatedly until it
              stops changing, then output the list of values, including the
              starting value.
       PN     Remove the last element. No-op if the list is empty.
   +M         Sum each list. This gives the cumulative sums in reverse order,
              including a 0 at the end for the empty list.
  S           Sort
.+            Deltas

TI-Basic, 20 bytes

cumSum(augment({0},Ans->L1
SortA(L1
ΔList(L1

Perl 5 , 87 + 1 (-a) = 88 bytes

$a[0]=1;push@a,$a[-1]+$_ for@F;@a=sort{$a<=>$b}@a;print$a[0]-$_,$"while($_=shift@a)&&@a

Pruébalo en línea!

VB.NET (.NET 4.5), 109 bytes

Sub A(n)
Dim c=n.count-1
For i=1To c
n(i)+=n(i-1)
Next
n.Sort()
For i=c To 1 Step-1
n(i)-=n(i-1)
Next
End Sub

Una función que espera una lista como entrada y la modifica directamente. El parámetro original se puede usar para la salida

1. Recrea una lista original agregando reenvíos a través de la lista (supone un 0 implícito como primer elemento)
2. Ordena la lista original
3. Obtiene las diferencias yendo hacia atrás (por lo que no necesito hacer un seguimiento de una lista diferente) (el primer elemento implícito de 0 significa que la primera diferencia es la misma que el elemento más pequeño)

Pruébalo en línea!

APL (Dyalog) , 15 14 bytes

-1 byte gracias a ngn .

(¯2-/⍋⊃¨⊂)0,+\

+\ suma acumulativa

0, anteponer un cero

(... ) aplique la siguiente función tácita sobre eso:

 ⊂ adjuntar (para que podamos elegir varios elementos)

 ⍋⊃¨ deje que cada uno de los índices que ordenaría el argumento elija

 ¯2-/ diferencia por pares invertida

Pruébalo en línea!

Solución original encontrada por los participantes de Code Golf Hackathon en la reunión de usuarios de Dyalog '17 :

¯2-/l[⍋l←+\0,⎕]

Pruébalo en línea!

⎕ solicitud de entrada

0, anteponer un cero

+\ suma acumulativa

l← almacenar como l

⍋ encuentra los índices que ordenarán l

l[... ] usa eso para indexarl

¯2-/ diferencia por pares invertida

MATL , 6 bytes

0hYsSd

Pruébalo en línea!

0       # push 0
 h      # horizontal concatenate with implicit input
  Ys    # cumulative sum
    S   # sort
     d  # diff (implicit output)

Gaia , 7 bytes

1¤++⊣ȯọ

Pruébalo en línea!

Explicación

1¤+      Prepend 1
   +⊣    Cumulative sums
     ȯ   Sort
      ọ  Deltas

k , 16 bytes

1_-':{x@<x}@+\0,

Pruébalo en línea!

              0, /prepend a 0
            +\   /cumulative sum
     {x@<x}@     /sort
1_-':            /differences list

Japt , 10 bytes

iT å+ n än

Pruébalo

Röda , 42 bytes

{i=0{[0];[i]if i+=_}|sort|slide 2|[_2-_1]}

Pruébalo en línea!

Esto es similar a la respuesta de Perl 6 . .sortes |sort, .rotor(2=>-1).flates |slide 2 y .map(*R-*)es |[_2-_1].

Explicación:

{
  i=0 /* initialize variable i */
  /* the following block recreates the original list from differences: */
  {
    [0];       /* push 0 to the stream */
    [i]if i+=_ /* add every number in the stream to i and push i back */
  }|
  sort|    /* sort the numbers */
  slide 2| /* for values i1, i2, i3, ... in the stream
              push pairs i1, i2, i2, i3, ... */
  [_2-_1]  /* calculate difference of numbers in each pair in the stream */
}

La declaración [i]if i+=_es equivalente a

for sfv do
  if i += sfv do
    push(i)
  done
done

El +=operador no envía valores a la secuencia, por lo que es veraz. También podría haber usado algún tipo de bloqueo (p. Ej. {|j|i+=j;[i]}_) Para unir la suma y las declaraciones, pero ifes más corto.

Julia 0.6.0 (34 bytes)

Más o menos una copia de lo que se ha hecho en R y Python 3

x->diff(sort(cumsum(vcat([0],x))))

J, 10 bytes

/:~&.(+/\)

explicación

"ordenar bajo suma de exploración": en J, la conjunción Bajo &.aplica la transformación a su derecha a la entrada, luego aplica el verbo a su izquierda (en este caso, ordenar /:~) y luego realiza la transformación inversa. Es decir, J entiende cómo invertir una suma de exploración, que es exactamente lo que se necesita aquí: las diferencias sucesivas son la entrada que, cuando se suma la exploración, producirá esa suma de exploración.

Pruébalo en línea!