22

Daftar perbedaan daftar bilangan bulat adalah perbedaan daftar anggota yang berurutan.

Misalnya daftar perbedaan

1, 3, 2 ,4

aku s

2, -1, 2

Tugas Anda adalah mengambil daftar perbedaan dan menampilkan seperti apa daftar perbedaan jika daftar asli disortir.

Misalnya daftar perbedaan

2, 1, -2, -1

Mungkin mewakili daftar

2 4 5 3 2

Yang saat disortir adalah

2 2 3 4 5

Yang memiliki daftar perbedaan

0 1 1 1

Ini adalah kode-golf sehingga jawaban akan dinilai dalam byte dengan lebih sedikit byte lebih baik.

code-golf array-manipulation

— Wisaya Gandum
sumber

Apakah solusi dijamin unik?

— H.PWiz

@ H.PWiz Ya mereka.

— Wheat Wizard

Terkait

— totallyhuman

1

@ H.PWiz Bukti cepat: daftar dapat direkonstruksi sempurna dari daftar perbedaan (DL) yang dikombinasikan dengan nilai elemen pertama, jadi ada konversi satu-ke-satu dari L ke (FV, DL). Meningkatkan FV dengan jumlah berapa pun sama dengan menambahkan jumlah itu ke setiap elemen L dan karena itu tidak dapat mengubah penyortiran L jika perbandingan itu sesuai monotonik. (Dengan kata lain, itu tidak mempengaruhi penyortiran kecuali jika angka yang Anda tambahkan menyebabkan bilangan bulat bilangan bulat).

— CR Drost

1

Bisakah Anda menambahkan beberapa test case lagi? Saya perhatikan beberapa solusi memberikan hasil yang berbeda [-2, 100, -2, -1], misalnya.

— Shaggy

16

05AB1E , 4 byte

.¥{¥

Cobalah online!

Penjelasan

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

— Datboi
sumber

Undelta05AB1E memiliki built-in niche paling banyak. o0

— totallyhuman

2

Ahh sial, pukul aku untuk itu. Saya selalu ingin menggunakan undelta.

— Magic Gurita Guci

16

Undeltaಠ ___ ಠ

— Business Cat

1

"Undelta" hanyalah jumlah kumulatif, bukan?

— Zgarb

2

@Zgarb Undelta menambahkan 0 sebagai elemen pertama dari daftar, lalu persis seperti yang Anda katakan, jumlah kumulatif atau membalikkan delta.

— Magic Octopus Mm

9

Python 3 dengan Numpy , 56 54 53 byte

2 byte off berkat @Artyer (Numpy sortbukannya standar sorted). 1 byte off berkat @ notjagan (pindah 0ke cumsum)

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

Kode mendefinisikan fungsi anonim yang memasukkan daftar atau array Numpy dan menampilkan array Numpy.

Cobalah online!

— Luis Mendo
sumber

1

Woah, Anda mengajari saya sesuatu yang baru hari ini. Pendekatan saya dengan numpyjauh lebih lama. Saya akan kembali besok untuk memperbaiki ini, karena saya melihat Anda sudah capped. Sangat bagus!

— Tn. Xcoder

@ Mr.Xcoder Terima kasih! Saya bukan ahli Numpy, saya hanya mengikuti apa yang telah saya lakukan di Matlab: diff(sort([0 cumsum(x)]))(di Matlab, [ ]adalah penggabungan)

— Luis Mendo

Tugas terpenuhi!

— Tn. Xcoder

-1 byte dengan memindahkan 0ke cumsum.

— notjagan

5

Mathematica, 40 byte

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

— J42161217
sumber

Differences@Sort@FoldList[+##&,1,#]&

— alephalpha

4

Jelly , 6 byte

0;+\ṢI

Cobalah online!

— Erik the Outgolfer
sumber

4

Sekam , 4 byte

Ẋ-O∫

Cobalah online!

Penjelasan

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

— H.Piz
sumber

Bahasa lain yang memiliki undelta? Atau built-in pelamun?

— Tn. Xcoder

@Bapak. Xcoder Terjadi bahwa cumsum sama dengan undelta

— H.PWiz

@ H.PWiz Sebenarnya bukan itu yang kami sebut cumsum ... kecuali jika Anda memasukkan awalan kosong ke dalam akun.

— Erik the Outgolfer

@EriktheOutgolfer Ya, itulah yang dilakukan sekam, seperti scanl(+)0di Haskell.

— H.PWiz

4

Pyth , 9 byte

-1 byte terima kasih kepada @EriktheOutgolfer .

.+S+0sM._

Test Suite.

Pyth , 10 byte

.+S.u+YNQ0

Cobalah online! atau Coba lebih banyak kasus uji .

— Tuan Xcoder
sumber

Seperti pada jawaban saya (yang dihapus), Anda dapat menggunakan +0sM._alih-alih .u+YNQ0untuk -1.

— Erik the Outgolfer

@EriktheOutgolfer Mengapa Anda menghapusnya?

— Tn. Xcoder

Kupikir ide intinya terlalu mirip denganmu.

— Erik the Outgolfer

@EriktheOutgolfer Ok, thanks then

— Mr. Xcoder

m=+Z is a same length variant for sM._, but sadly it doesn't seem like it can be any shorter.

— FryAmTheEggman

4

JavaScript (ES6), 57 56 bytes

Saved 1 byte thanks to @ETHproductions

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

Demo

Show code snippet

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

Expand snippet

— Arnauld
sumber

.sort((a,b)=>a-b) That's the way to get deltas? By sorting with subtraction? :P

— totallyhuman

@totallyhuman The first map() gives the deltas. This code sorts them. The 2nd map rebuild the new deltas. The JS sort() method uses lexicographical order by default. So, we need this specialized callback for numbers > 9 (sadly).

— Arnauld

That -p+(p=n) grinds my gears, but sadly there's no better way... unless...

— ETHproductions

what the heck, I didn't press the submit button >_< But anyway, I think you can save a byte with that edit...

— ETHproductions

@ETHproductions Thanks :-)

— Arnauld

3

Java 8, 123 bytes

The standard solution: cumulative sum input, sort, then diff. No substantial implementation tricks either.

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[]>. Output is mutated input.

Try It Online

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

Acknowledgments

-3 bytes thanks to Olivier Grégoire, master of unholy autoincrementation
-1 byte thanks to Nevay

— Jakob
sumber

1

You can golf 3 bytes by rearranging the positions where you do your increments and your overall computations:

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

(beware SE's invisible characters when copy/pasting)

— Olivier Grégoire

1

Thanks for my new title ;) Here's more decrement unholiness to celebrate for(;i>0;)l[i-1]=d[i]-d[--i]; (last loop)

— Olivier Grégoire

I had just reworked that loop myself, arriving at for(;i-->0;)l[i]=d[i+1]-d[i]; of the same length. Update to come.

— Jakob

2

You can save 1 byte by using

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

.

— Nevay

Ah yes, of course. Thanks!

— Jakob

2

Brachylog, 15 bytes

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

Try it online!

— Erik the Outgolfer
sumber

2

R, 31 32 bytes

-4 bytes thanks to @user2390246 for diffinv

+5 bytes from Jarko for cat

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

Reads from stdin, writes to stdout. diffinv is an inverse of diff for a given starting value (0 by default). Since it's diffed again, it doesn't matter what that value is.

As pointed out by Jarko Dubbeldam, I needed to properly output the result, at the cost of five bytes. Alas.

Try it online!

— Giuseppe
sumber

That's what I had in mind as well. Does need to handle printing though, as running this as a full program (through source) this doesn't output anything.

— JAD

1

If you use diffinv rather than cumsum you don't need to prepend zero.

— user2390246

@user2390246 wow, very nice! TIL about diffinv.

— Giuseppe

Me too! I was just having a quick search to see if there were any previous answers I could have applied it to.

— user2390246

1

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

Try it online!

Horrible solution.

— totallyhuman
sumber

It's not that terrible, in fact

— Mr. Xcoder

Python's += operator on lists works with any iterable, so you can use r+=r[-1]+i, instead of r+=[r[-1]+i] and save one byte.

— Jonathan Frech

1

Perl 6, 46 bytes

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

Try it

Expanded:

{  # 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)
}

— Brad Gilbert b2gills
sumber

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

Try it online!

Straightforward.

— jferard
sumber

3

=<< from the function monad comes in handy: (zipWith(-)=<<tail).sort.scanl(+)0

— nimi

@nimi Very nice. I'm not expert in monads, but I should have thought of zipWith.

— jferard

1

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

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

Prompts for user input. The list must be input with a leading {, with numbers separated by ,, and with an optional trailing }.

TI-Basic is a tokenized language; ΔList( and cumSum( are two-byte tokens, all other tokens used are one byte each.

Example run (with NAME as the program name and {4,-2,7,-4,0} as the input):

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

Explanation:

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

— pizzapants184
sumber

Do you need the L's?

— Zacharý

@Zacharý you can omit them when storing a list, but omitting them when referencing would refer to the numerical variable X instead of the list

— pizzapants184

1

C++ (gcc), 136 bytes

As unnamed generic lambda, assuming input to be like std::list and returning via reference parameter.

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

Try it online!

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
}

— Karl Napf
sumber

1

Pyth, 8 bytes

.+S+M.uP

Demonstration

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

— isaacg
sumber

+1 This is a neat workaround with cumulative fixed point. I personally didn't even think of this.

— Mr. Xcoder

1

TI-Basic, 20 bytes

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

— Timtech
sumber

1

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

Try it online!

— Xcali
sumber

1

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

A function that expects a list as input and modifies it directly. The original parameter can then be used for output

Recreates an original list by adding forwards through the list (assumes an implicit 0 as the first element)
Sorts the original list
Gets the differences by going backwards (so I don't need to keep track of a different list) (the implicit first element of 0 means the first difference is the same as the smallest element)

Try it online!

— Brian J
sumber

Would you mind updating the TIO link?

— Taylor Scott

@TaylorScott Update in what way?

— Brian J

Your TIO link shows completely different code than in your answer

— Taylor Scott

1

@TaylorScott Ahh....I see. I had to make some adjustments because TIO uses Mono, but I was using the .NET 4.5 compiler

— Brian J

1

APL (Dyalog), 15 14 bytes

-1 byte thanks to ngn.

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

+\ cumulative sum

0, prepend a zero

(…) apply the following tacit function on that:

⊂ enclose (so we can pick multiple items)

⍋⊃¨ let each of the indices that would sort the argument pick from that

¯2-/ reversed pairwise difference

Try it online!

Original solution found by the Code Golf Hackathon participants at the Dyalog '17 User Meeting:

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

Try it online!

⎕ prompt for input

0, prepend a zero

+\ cumulative sum

l← store as l

⍋ find the indices that will sort l

l[…] use that to index into l

¯2-/ reversed pairwise difference

— Adám
sumber

1

I don't know if this was allowed at the hackathon but if you rewrite it in point-free style you could save a char: (¯2-/⍋⊃¨⊂)0,+\

— ngn

@ngn This part of the workshop was attempting to get the participants started with PPCG, so the rules here were those of PPCG. Thanks.

— Adám

1

MATL, 6 bytes

0hYsSd

Try it online!

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

— Giuseppe
sumber

0

Gaia, 7 bytes

1¤++⊣ȯọ

Try it online!

Explanation

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

— Business Cat
sumber

0

k, 16 bytes

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

Try it online!

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

— zgrep
sumber

0

Japt, 10 bytes

iT å+ n än

Test it

— Shaggy
sumber

0

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.

— fergusq
sumber

0

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

— Goysa
sumber

0

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!

— Jonah
sumber

Sortir daftar perbedaan

05AB1E , 4 byte

Penjelasan

Python 3 dengan Numpy , 56 54 53 byte

Mathematica, 40 byte

Jelly , 6 byte

Sekam , 4 byte

Penjelasan

Pyth , 9 byte

Pyth , 10 byte

JavaScript (ES6), 57 56 bytes

Demo

Java 8, 123 bytes

Ungolfed lambda

Acknowledgments

Brachylog, 15 bytes

R, 31 32 bytes

Python 2, 83 bytes

Perl 6, 46 bytes

Expanded:

Haskell, 74 bytes

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

C++ (gcc), 136 bytes

Pyth, 8 bytes

TI-Basic, 20 bytes

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

VB.NET (.NET 4.5), 109 bytes

APL (Dyalog), 15 14 bytes

MATL, 6 bytes

Gaia, 7 bytes

Explanation

k, 16 bytes

Japt, 10 bytes

Röda, 42 bytes

Julia 0.6.0 (34 bytes)

J, 10 bytes

explanation