Danh sách khác biệt của danh sách các số nguyên là sự khác biệt danh sách của các thành viên liên tiếp.

Ví dụ: danh sách khác biệt của

1, 3, 2 ,4

Là

2, -1, 2

Nhiệm vụ của bạn là nhận đầu vào một danh sách khác biệt và đưa ra danh sách khác biệt sẽ như thế nào nếu danh sách ban đầu được sắp xếp.

Ví dụ: danh sách khác biệt

2, 1, -2, -1

Có thể đại diện cho một danh sách

2 4 5 3 2

Mà khi sắp xếp là

2 2 3 4 5

Trong đó có một danh sách khác biệt của

0 1 1 1

Đây là môn đánh gôn, vì vậy câu trả lời sẽ được tính bằng byte với ít byte hơn.

05AB1E , 4 byte

.¥{¥

Hãy thử trực tuyến!

Giải trình

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

Python 3 với Numpy , 56 54 53 byte

Giảm 2 byte nhờ @Artyer (Numpy sortthay vì tiêu chuẩn sorted). Giảm 1 byte nhờ @notjagan (chuyển 0vào cumsum)

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

Mã xác định một hàm ẩn danh nhập một danh sách hoặc một mảng Numpy và xuất ra một mảng Numpy.

Hãy thử trực tuyến!

Toán học, 40 byte

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

Thạch , 6 byte

0;+\ṢI

Hãy thử trực tuyến!

Husk , 4 byte

Ẋ-O∫

Hãy thử trực tuyến!

Giải thích

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

Bình thường , 9 byte

-1 byte nhờ @EriktheOutgolfer .

.+S+0sM._

Phòng thử nghiệm.

Bình thường , 10 byte

.+S.u+YNQ0

Hãy thử trực tuyến! hoặc Thử nhiều trường hợp thử nghiệm .

JavaScript (ES6), 57 56 byte

Đã lưu 1 byte nhờ @ETHproductions

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

Bản giới thiệu

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 byte

Các giải pháp tiêu chuẩn: đầu vào tổng tích lũy, sắp xếp, sau đó khác. Không có thủ thuật thực hiện đáng kể hoặc.

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

Đúc để Consumer<int[]>. Đầu ra là đầu vào đột biến.

Dùng thử trực tuyến

Lambda

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

Lời cảm ơn

• -3 byte nhờ Olivier Grégoire , bậc thầy về tự động hóa không linh hoạt
• -1 byte nhờ Nevay

Brachylog , 15 byte

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

Hãy thử trực tuyến!

R , 31 32 byte

-4 byte nhờ @ user2390246 cho diffinv

+5 byte từ Jarko cho cat

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

Đọc từ stdin, viết đến stdout. diffinvlà một nghịch đảo của diffmột giá trị bắt đầu nhất định (0 theo mặc định). Vì nó là diffed một lần nữa, nó không quan trọng giá trị đó là gì.

Như Jarko Dubbeldam đã chỉ ra, tôi cần phải đưa ra kết quả chính xác, với chi phí là năm byte. Than ôi.

Hãy thử trực tuyến!

Python 2 , 83 byte

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

Hãy thử trực tuyến!

Giải pháp kinh khủng .

Perl 6 , 46 byte

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

Thử nó

Mở rộng:

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

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

Hãy thử trực tuyến!

Nói thẳng ra.

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

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

Nhắc nhở cho người dùng đầu vào. Danh sách phải được nhập với một đầu {, với các số được phân tách bằng ,và theo sau là một tùy chọn }.

TI-Basic là ngôn ngữ được mã hóa ; ΔList(và cumSum(là các mã thông báo hai byte, tất cả các mã thông báo khác được sử dụng là mỗi byte một byte.

Chạy ví dụ (với NAMEtên chương trình và {4,-2,7,-4,0}đầu vào):

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

Giải trình:

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 byte

Như lambda chung chưa được đặt tên, giả sử đầu vào giống std::listvà trở lại thông qua tham số tham chiếu.

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

Hãy thử trực tuyến!

Ung dung:

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

Bình thường, 8 byte

.+S+M.uP

Trình diễ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 byte

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

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

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

Hãy thử trực tuyến!

VB.NET (.NET 4.5), 109 byte

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

Một chức năng mong đợi một danh sách là đầu vào và sửa đổi nó trực tiếp. Tham số ban đầu sau đó có thể được sử dụng cho đầu ra

1. Tạo lại danh sách ban đầu bằng cách thêm chuyển tiếp qua danh sách (giả sử 0 ẩn là phần tử đầu tiên)
2. Sắp xếp danh sách ban đầu
3. Có được sự khác biệt bằng cách quay ngược (vì vậy tôi không cần theo dõi một danh sách khác) (yếu tố đầu tiên ẩn là 0 có nghĩa là sự khác biệt đầu tiên giống như yếu tố nhỏ nhất)

Hãy thử trực tuyến!

APL (Dyalog) , 15 14 byte

-1 byte nhờ ngn .

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

+\ Tổng tích lũy

0, trả trước một số không

(... ) áp dụng các chức năng ngầm sau trên rằng:

 ⊂ kèm theo (để chúng tôi có thể chọn nhiều mặt hàng)

 ⍋⊃¨ hãy để mỗi chỉ số sắp xếp đối số chọn từ đó

 ¯2-/ đảo ngược sự khác biệt cặp

Hãy thử trực tuyến!

Giải pháp ban đầu được tìm thấy bởi những người tham gia Code Golf Hackathon tại Cuộc họp người dùng của Dyalog '17 :

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

Hãy thử trực tuyến!

⎕ nhắc nhở cho đầu vào

0, trả trước một số không

+\ Tổng tích lũy

l← lưu trữ như l

⍋ tìm các chỉ số sẽ sắp xếp l

l[Sọ ] sử dụng nó để lập chỉ mục vàol

¯2-/ đảo ngược sự khác biệt cặp

MATL , 6 byte

0hYsSd

Hãy thử trực tuyến!

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

Gaia , 7 byte

1¤++⊣ȯọ

Hãy thử trực tuyến!

Giải trình

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

k , 16 byte

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

Hãy thử trực tuyến!

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

Japt , 10 byte

iT å+ n än

Kiểm tra nó

Röda , 42 byte

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

Hãy thử trực tuyến!

Điều này tương tự như câu trả lời Perl 6 . .sortlà |sort, .rotor(2=>-1).flatlà |slide 2 và .map(*R-*)là |[_2-_1].

Giải trình:

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

Tuyên bố [i]if i+=_tương đương với

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

Các +=nhà điều hành không đẩy giá trị cho luồng dữ liệu, vì vậy nó là truthy. Tôi cũng có thể đã sử dụng một số loại khối (ví dụ. {|j|i+=j;[i]}_) Để gắn các câu lệnh cộng và đẩy với nhau, nhưng ifngắn hơn.

Julia 0,6.0 (34 byte)

Khá nhiều bản sao của những gì đã được thực hiện trong R và Python 3

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

J, 10 byte

/:~&.(+/\)

giải trình

"sort under scan sum": Trong J, kết hợp Under &.áp dụng phép biến đổi sang phải của nó cho đầu vào, sau đó áp dụng động từ sang trái (trong trường hợp này là sắp xếp /:~ngược lại) và sau đó thực hiện chuyển đổi ngược lại. Nghĩa là, J hiểu cách đảo ngược tổng quét, đó chính xác là những gì cần thiết ở đây: sự khác biệt kế tiếp là đầu vào mà khi quét tổng hợp sẽ tạo ra tổng quét đó.

Hãy thử trực tuyến!