รายการความแตกต่างของรายการจำนวนเต็มคือความแตกต่างของรายการสมาชิกที่ต่อเนื่องกัน

ตัวอย่างเช่นรายการความแตกต่างของ

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

นี่คือcode-golfดังนั้นคำตอบจะได้คะแนนเป็นไบต์ด้วยจำนวนไบต์น้อยกว่าจะดีกว่า

05AB1E , 4 ไบต์

.¥{¥

ลองออนไลน์!

คำอธิบาย

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

Python 3 ที่มีNumpy , 56 54 53 ไบต์

ปิด 2 ไบต์ด้วย@Artyer (Numpy sortแทนที่จะเป็นแบบมาตรฐาน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

ลองออนไลน์!

Husk , 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 ไบต์

-1 ขอบคุณไบต์ @EriktheOutgolfer

.+S+0sM._

ชุดทดสอบ

Pyth , 10 ไบต์

.+S.u+YNQ0

ลองออนไลน์! หรือลองกรณีทดสอบเพิ่มเติม

JavaScript (ES6), 57 56 ไบต์

บันทึกแล้ว 1 ไบต์ขอบคุณ@ETHproductions

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 ไบต์ขอบคุณ Olivier Grégoireผู้เชี่ยวชาญด้านการซ่อมบำรุงอัตโนมัติที่ไม่บริสุทธิ์
• -1 ไบต์ด้วยNevay

Brachylogขนาด 15 ไบต์

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

ลองออนไลน์!

R , 31 32 ไบต์

-4 ไบต์ต้องขอบคุณ @ user2390246 สำหรับ diffinv

+5 ไบต์จาก Jarko สำหรับ cat

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

อ่านจาก stdin เขียนถึง stdout diffinvเป็นสิ่งที่ตรงกันข้ามdiffค่าเริ่มต้นที่กำหนด (0 โดยค่าเริ่มต้น) เนื่องจากมันเป็นdiffed อีกครั้งมันไม่สำคัญว่าค่านั้นคืออะไร

ตามที่ Jarko Dubbeldam ชี้ให้เห็นฉันจำเป็นต้องแสดงผลลัพธ์อย่างถูกต้องด้วยราคาห้าไบต์ อนิจจา.

ลองออนไลน์!

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 เป็นภาษา tokenized ; ΔList(และcumSum(เป็นโทเค็นสองไบต์, โทเค็นอื่น ๆ ที่ใช้ทั้งหมดเป็นหนึ่งไบต์ในแต่ละ

ตัวอย่างการรัน (ด้วย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);}

ลองออนไลน์!

Ungolfed:

[](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 ไบต์

-1 ขอบคุณไบต์NGN

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

+\ ยอดรวมสะสม

0, เติมศูนย์

(... ) ใช้ฟังก์ชัน tacit ต่อไปนี้กับสิ่งนั้น:

 ⊂ ใส่ (เพื่อให้เราสามารถเลือกได้หลายรายการ)

 ⍋⊃¨ ให้แต่ละดัชนีที่จะเรียงลำดับการโต้แย้งเลือกจากที่

 ¯2-/ กลับความแตกต่างของจำนวนคู่

ลองออนไลน์!

โซลูชันดั้งเดิมที่พบโดยผู้เข้าร่วม Code Golf Hackathon ในการประชุมผู้ใช้ Dyalog '17 :

¯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)

Gaiaขนาด 7 ไบต์

1¤++⊣ȯọ

ลองออนไลน์!

คำอธิบาย

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

k, 16 bytes

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

Try it online!

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

Japt, 10 bytes

iT å+ n än

Test it

Röda, 42 bytes

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

Try it online!

This is similar to the Perl 6 answer. .sort is |sort, .rotor(2=>-1).flat is |slide 2 and .map(*R-*) is |[_2-_1].

Explanation:

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

The statement [i]if i+=_ is equivalent to

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

The += operator does not push values to the stream, so it is truthy. I could also have used some kind of block (eg. {|j|i+=j;[i]}_) to tie the addition and pushing statements together, but if is shorter.

Julia 0.6.0 (34 bytes)

Pretty much a copy of what has been done in R and Python 3

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

J, 10 bytes

/:~&.(+/\)

explanation

"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!