整数のリストの差分リストは、連続するメンバーのリストの差分です。

たとえば、

1, 3, 2 ,4

は

2, -1, 2

あなたのタスクは、入力として差分リストを取得し、元のリストがソートされた場合の差分リストの外観を出力することです。

たとえば、差分リスト

2, 1, -2, -1

リストを表す場合があります

2 4 5 3 2

ソートされるとき

2 2 3 4 5

の違いリストがあります

0 1 1 1

これはコードゴルフであるため、回答はバイト単位でスコアリングされ、バイト数が少ない方が優れています。

05AB1E、4バイト

.¥{¥

オンラインでお試しください！

説明

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

パイソン3とnumpyの、56の 54、53バイト

@Artyerのおかげで2バイトオフになりました（sort標準ではなくNumpyのものsorted）。おかげオフ1バイト@notjagan（移動0中にcumsum）

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

コードは、リストまたはNumpy配列を入力し、Numpy配列を出力する匿名関数を定義します。

オンラインでお試しください！

Mathematica、40バイト

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

ゼリー、6バイト

0;+\ṢI

オンラインでお試しください！

殻、4バイト

Ẋ-O∫

オンラインでお試しください！

説明

      -- 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バイト

@EriktheOutgolferのおかげで-1バイト。

.+S+0sM._

テストスイート。

Pyth、10バイト

.+S.u+YNQ0

オンラインでお試しください！または、さらにテストケースを試してください。

JavaScript（ES6）、57 56バイト

@ETHproductionsのおかげで1バイト節約

a=>a.map(n=>t-=n,p=t=0).sort((a,b)=>b-a).map(n=>p-(p=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バイト

標準ソリューション：累積合計入力、並べ替え、差分。実質的な実装のトリックもありません。

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

にキャストしConsumer<int[]>ます。出力は変更された入力です。

オンラインで試す

ゴルフされていないラムダ

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

謝辞

• 不浄な自動インクリメントのマスター、オリビエグレゴワールのおかげで-3バイト
• Nevayのおかげで-1バイト

Brachylog、15バイト

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

オンラインでお試しください！

R、31 32バイト

-4バイト、@ user2390246のおかげで diffinv

Jarkoから+5バイト cat

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

stdinから読み取り、stdoutに書き込みます。diffinvは、diff指定された開始値の逆数です（デフォルトでは0）。それはだからdiff、再び編、その値が何であるかは重要ではありません。

Jarko Dubbeldamが指摘したように、5バイトのコストで結果を適切に出力する必要がありました。ああ。

オンラインでお試しください！

Python 2、83バイト

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

オンラインでお試しください！

恐ろしい解決策。

Perl 6、46バイト

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

それを試してみてください

拡張：

{  # 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バイト

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

オンラインでお試しください！

簡単です。

TI-Basic（TI-84 Plus CE）、23 バイト

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

ユーザー入力のプロンプト。リストは、先頭に{、で区切られた数字,があり、オプションの末尾がある入力でなければなりません}。

TI-Basicはトークン化された言語です。ΔList(およびcumSum(は2バイトのトークンであり、使用される他のすべてのトークンはそれぞれ1バイトです。

実行例（NAMEプログラム名および{4,-2,7,-4,0}入力として）：

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

説明：

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バイト

名前のないジェネリックラムダとして、入力が同様であるstd::listと仮定し、参照パラメーターを介して戻る。

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

オンラインでお試しください！

ゴルフをしていない：

[](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バイト

.+S+M.uP

デモンストレーション

.+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バイト

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

Perl 5、87 + 1（-a）= 88バイト

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

オンラインでお試しください！

VB.NET（.NET 4.5）、109バイト

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

入力としてリストを予期し、それを直接変更する関数。その後、元のパラメーターを出力に使用できます

1. リストを前方に追加して元のリストを再作成します（最初の要素として暗黙的な0を想定しています）
2. 元のリストを並べ替えます
3. 後方に移動して差を取得します（したがって、別のリストを追跡する必要はありません）（0の暗黙の最初の要素は、最初の差が最小の要素と同じであることを意味します）

オンラインでお試しください！

APL（Dyalog）、15 14バイト

ngnのおかげで-1バイト。

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

+\ 累計

0, ゼロを追加します

(… ) 次の暗黙関数を適用します：

 ⊂ 同封（複数のアイテムを選択できるようにするため）

 ⍋⊃¨ 引数を並べ替える各インデックスにその中から選択させます

 ¯2-/ 逆のペアワイズ差

オンラインでお試しください！

Dyalog '17ユーザーミーティングでCode Golf Hackathon参加者が見つけた元のソリューション：

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

オンラインでお試しください！

⎕ 入力を促す

0, ゼロを追加します

+\ 累計

l← として保存 l

⍋ ソートするインデックスを見つける l

l[…を] 使用してインデックスを作成するl

¯2-/ 逆のペアワイズ差

MATL、6バイト

0hYsSd

オンラインでお試しください！

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

ガイア、7バイト

1¤++⊣ȯọ

オンラインでお試しください！

説明

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

k、16バイト

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

オンラインでお試しください！

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

Japt、10バイト

iT å+ n än

試して

ロダ、42バイト

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

オンラインでお試しください！

これは、Perl 6の回答に似ています。.sortで|sort、.rotor(2=>-1).flatある|slide 2 と.map(*R-*)され|[_2-_1]です。

説明：

{
  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 */
}

ステートメント[i]if i+=_は次と同等です

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

+=それはtruthyあるので、オペレータは、ストリームに値をプッシュしていません。また、ある種のブロック（例：）を使用して{|j|i+=j;[i]}_、追加ステートメントとプッシュステートメントを結び付けることもできますが、ifより短いものです。

ジュリア0.6.0（34バイト）

RおよびPython 3で行われたことのほとんどコピー

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

J、10バイト

/:~&.(+/\)

説明

「スキャン合計の下でソート」：Jでは、Underコン&.ジャンクションは変換を入力の右側に適用し、次に動詞を左側に適用し（この場合はsort /:~）、逆変換を実行します。つまり、Jはスキャン合計を反転する方法を理解します。これはまさにここで必要なものです。連続する違いは、スキャン合計時にそのスキャン合計を生成する入力です。

オンラインでお試しください！