La liste des différences d'une liste d'entiers est la liste des différences des membres consécutifs.

Par exemple, la liste des différences de

1, 3, 2 ,4

est

2, -1, 2

Votre tâche consiste à prendre en entrée une liste de différences et à afficher à quoi ressemblerait la liste de différences si la liste d'origine était triée.

Par exemple la liste des différences

2, 1, -2, -1

Pourrait représenter une liste

2 4 5 3 2

Qui, une fois trié, est

2 2 3 4 5

Qui a une liste de différences de

0 1 1 1

Il s'agit de code-golf, donc les réponses seront notées en octets avec moins d'octets meilleurs.

05AB1E , 4 octets

.¥{¥

Essayez-le en ligne!

Explication

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

Python 3 avec Numpy , 56 54 53 octets

2 octets de moins grâce à @Artyer (Numpy au sortlieu du standard sorted). 1 octet off grâce à @notjagan (déplacement 0en cumsum)

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

Le code définit une fonction anonyme qui entre une liste ou un tableau Numpy et sort un tableau Numpy.

Essayez-le en ligne!

Mathematica, 40 octets

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

Gelée , 6 octets

0;+\ṢI

Essayez-le en ligne!

Husk , 4 octets

Ẋ-O∫

Essayez-le en ligne!

Explication

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

-1 octet grâce à @EriktheOutgolfer .

.+S+0sM._

Suite de tests.

Pyth , 10 octets

.+S.u+YNQ0

Essayez-le en ligne! ou Essayez d'autres cas de test .

JavaScript (ES6), 57 56 octets

1 octet enregistré grâce à @ETHproductions

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

Démo

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 octets

La solution standard: somme cumulée saisie, tri, puis diff. Aucune astuce de mise en œuvre substantielle non plus.

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

Cast to Consumer<int[]>. La sortie est une entrée mutée.

Essayez-le en ligne

Lambda non 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];
}

Remerciements

• -3 octets grâce à Olivier Grégoire , maître de l'auto-incrémentation impie
• -1 octet grâce à Nevay

Brachylog , 15 octets

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

Essayez-le en ligne!

R , 31 32 octets

-4 octets grâce à @ user2390246 pour diffinv

+5 octets de Jarko pour cat

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

Lit depuis stdin, écrit vers stdout. diffinvest l'inverse de diffpour une valeur de départ donnée (0 par défaut). Puisqu'il est à diffnouveau édité, peu importe quelle est cette valeur.

Comme l'a souligné Jarko Dubbeldam, j'avais besoin de produire correctement le résultat, au prix de cinq octets. Hélas.

Essayez-le en ligne!

Python 2 , 83 octets

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

Essayez-le en ligne!

Solution horrible .

Perl 6 , 46 octets

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

Essayez-le

Étendu:

{  # 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 octets

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

Essayez-le en ligne!

Simple.

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

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

Invite l'utilisateur à entrer. La liste doit être entrée avec un début {, avec des nombres séparés par ,et avec une fin facultative }.

TI-Basic est un langage à jetons ; ΔList(et cumSum(sont des jetons de deux octets, tous les autres jetons utilisés sont d'un octet chacun.

Exemple d'exécution (avec NAMEcomme nom de programme et {4,-2,7,-4,0}comme entrée):

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

Explication:

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 octets

En tant que lambda générique sans nom, en supposant que l'entrée est similaire std::listet en retournant via le paramètre de référence.

[](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);}

Essayez-le en ligne!

Non 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 octets

.+S+M.uP

Manifestation

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

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

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

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

Essayez-le en ligne!

VB.NET (.NET 4.5), 109 octets

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

Une fonction qui attend une liste en entrée et la modifie directement. Le paramètre d'origine peut ensuite être utilisé pour la sortie

1. Recrée une liste originale en ajoutant vers l'avant à travers la liste (suppose un 0 implicite comme premier élément)
2. Trie la liste d'origine
3. Obtient les différences en reculant (donc je n'ai pas besoin de garder une trace d'une liste différente) (le premier élément implicite de 0 signifie que la première différence est la même que le plus petit élément)

Essayez-le en ligne!

APL (Dyalog) , 15 14 octets

-1 octet grâce à ngn .

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

+\ somme cumulée

0, ajouter un zéro

(… ) Appliquer la fonction tacite suivante à cela:

 ⊂ joindre (afin que nous puissions choisir plusieurs articles)

 ⍋⊃¨ laissez chacun des indices qui trierait l'argument choisir

 ¯2-/ différence par paire inversée

Essayez-le en ligne!

Solution originale trouvée par les participants du Code Golf Hackathon lors de la réunion des utilisateurs de Dyalog '17 :

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

Essayez-le en ligne!

⎕ demande de saisie

0, ajouter un zéro

+\ somme cumulée

l← stocker sous l

⍋ trouver les indices qui trieront l

l[… ] Utilisez-le pour indexerl

¯2-/ différence par paire inversée

MATL , 6 octets

0hYsSd

Essayez-le en ligne!

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

Gaia , 7 octets

1¤++⊣ȯọ

Essayez-le en ligne!

Explication

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

k , 16 octets

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

Essayez-le en ligne!

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

Japt , 10 octets

iT å+ n än

Essaye-le

Röda , 42 octets

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

Essayez-le en ligne!

Ceci est similaire à la réponse Perl 6 . .sortest |sort, .rotor(2=>-1).flatest |slide 2 et .map(*R-*)est |[_2-_1].

Explication:

{
  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 déclaration [i]if i+=_équivaut à

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

L' +=opérateur ne pousse pas de valeurs dans le flux, c'est donc vrai. J'aurais également pu utiliser une sorte de bloc (par exemple. {|j|i+=j;[i]}_) Pour lier l'addition et pousser les instructions ensemble, mais ifc'est plus court.

Julia 0.6.0 (34 octets)

À peu près une copie de ce qui a été fait dans R et Python 3

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

J, 10 octets

/:~&.(+/\)

explication

"sort under scan sum": In J, the Under conjunction &. applies the transformation to its right to the input, then applies the verb to its left (in this case sort /:~) and then does the reverse transformation. That is, J understands how to invert a scan sum, which is exactly what's needed here: the successive differences are the input that, when scan-summed, will produce that scan-sum.

Try it online!