Tampaknya setiap Modifikasi Sederhana dari delta menggunakan fungsi yang konsisten hampir selalu dapat dilakukan dengan cara lain yang lebih singkat , Dennis . Dengan demikian, satu-satunya solusi yang dapat saya bayangkan untuk membuat ini lebih sulit, adalah dengan memperkenalkan semacam fungsi yang tidak konsisten.

Penyortiran.

Tugas Anda adalah mengambil array bilangan bulat, mengurutkan delta-delta mereka, dan mengkompilasi ulangnya untuk memberikan array bilangan bulat baru.

MISALNYA.

Untuk input:

1  5 -3  2  9

Dapatkan Delta berikut:

  4 -8  5  7

Kemudian, urutkan Delta ini, Menghasilkan:

 -8  4  5  7

Dan aplikasikan kembali, yang memberi:

1 -7 -3  2  9

Input output

Anda akan diberikan daftar / array / tabel / tuple / stack / dll. bilangan bulat yang ditandatangani sebagai input melalui metode input standar apa pun.

Anda harus mengeluarkan data yang dimodifikasi sekali lagi dalam bentuk apa pun yang dapat diterima, mengikuti metode pengurutan delta di atas.

Anda akan menerima input N di 0 < N < 10mana setiap angka berada dalam kisaran-1000 < X < 1000

Uji Kasus

1 5 -3 2 9   -> 1 -7 -3 2 9
-5 -1 -6 5 8 -> -5 -10 -7 -3 8
-8 1 -7 1 1  -> -8 -16 -16 -8 1
8 -9 3 0 -2  -> 8 -9 -12 -14 -2
-5 -2 -5 5 0 -> -5 -10 -13 -10 0
-1 9 -1 -7 9 -> -1 -11 -17 -7 9

Catatan

• Seperti yang dinyatakan di atas, Anda akan selalu menerima setidaknya 1 input, dan tidak lebih dari 9.
• Angka pertama dan terakhir dari output Anda, akan selalu cocok dengan input.
• Hanya Output Input Standar yang diterima
• Celah standar berlaku
• Ini adalah kode-golf , jadi byte-count terendah menang!
• Selamat bersenang-senang!

Jelly , 7 byte

IṢ;@Ḣ+\

Cobalah online!

Bagaimana itu bekerja

IṢ;@Ḣ+\  Main link. Argument: A (array)

I        Increments; compute the deltas.
 Ṣ       Sort them.
    Ḣ    Head; pop and yield the first element of A.
  ;@     Concatenate with swapped arguments.
     +\  Take the cumulative sum.

MATL , 8 byte

1)GdShYs

Cobalah online!

1)   % Implicit input. Get its first entry
G    % Push input again
d    % Differences
S    % Sort
h    % Concatenate
Ys   % Cumulative sum. Implicit display

Mathematica, 40 byte

FoldList[Plus,#&@@#,Sort@Differences@#]&

Fungsi murni mengambil daftar (anythings) sebagai input dan mengembalikan daftar. FoldList[Plusdimulai dengan angka (dalam hal ini,, #&@@#elemen pertama dari input) dan berulang kali menambahkan elemen dari daftar penjelasan sendiri Sort@Differences@#. Ini meniru perilaku built-in Accumulate, tetapi angka pertama harus ditambahkan ke daftar perbedaan dengan tangan, yang membuat byte-count lebih tinggi (sejauh yang saya tahu).

05AB1E , 9 byte

-4 Terima kasih kepada Emigna

¬=s¥{vy+=

Cobalah online!

¬         # Get the head
 =        # Print
  s¥{     # Get sorted Deltas
     vy   # For each
       += # Add to the previous value and print

Python 2, 92 byte

l=input();p=0;d=[]
r=l[0],
for e in l:d+=e-p,;p=e
for e in sorted(d[1:]):r+=r[-1]+e,
print r

Haskell, 59 Bytes

import Data.List
f l@(a:b)=scanl1(+)$a:(sort$zipWith(-)b l)

Kerusakan:

f l@(a:b) =           --we create a function f that takes as input a list l with head a and tail b
zipWith(-)b l        --we make a new list with the deltas
sort$                    --sort it
a:                          --prepend a to the list
scanl1(+)$          --create a new list starting with a and adding the deltas to it cumulatively

JavaScript (ES6), 68 byte

([p,...a])=>[s=p,...a.map(e=>p-(p=e)).sort((a,b)=>b-a).map(e=>s-=e)]

Dalam JavaScript ternyata menjadi pemain golf untuk menghitung Delta Inverse dari sebuah array . Ini kemudian disortir dalam urutan menurun dan secara kumulatif dikurangi dari elemen pertama.

Python 2 ,

90 byte

x=input()
print[sum(sorted(map(int.__sub__,x[1:],x[:-1]))[:i])+x[0]for i in range(len(x))]

84 byte

Disimpan 6 byte menggunakan lambda. Terima kasih untuk ovs!

lambda x:[sum(sorted(map(int.__sub__,x[1:],x[:-1]))[:i])+x[0]for i in range(len(x))]

Cobalah online!

Memecah kode,

>>> x
[1, 5, -3, 2, 9]
>>> map(int.__sub__,x[1:],x[:-1]) #delta
[4, -8, 5, 7]
>>> sorted(map(int.__sub__,x[1:],x[:-1])) #sorted result
[-8, 4, 5, 7]
>>> [sorted(map(int.__sub__,x[1:],x[:-1]))[:i]for i in range(len(x))]
[[], [-8], [-8, 4], [-8, 4, 5], [-8, 4, 5, 7]]
>>> [sum(sorted(map(int.__sub__,x[1:],x[:-1]))[:i])+x[0]for i in range(len(x))]
[1, -7, -3, 2, 9]

Selamat Coding!

JavaScript (ES6), 93 byte

(p,M=[p[0]])=>p.map((a,b)=>p[b+1]-a).sort((a,b)=>a-b).map((a,b)=>M=[...M,M[b]+a])[p.length-2]

Python 2 , 97 byte

p=input()
d=[p[i+1]-p[i] for i in range(len(p)-1)]
o=p[:1]
for n in sorted(d):o+=o[-1]+n,
print o

Cobalah online!

Pyth, 11 byte

.u+NYS.+QhQ

Ini hanya melakukan hal yang jelas dijelaskan dalam pernyataan.

Cobalah secara Online

      .+Q    Take the deltas of the input
     S       sort it
.u           Cumulative reduce
  +NY        using addition
         hQ  starting with the first element of the input

Saran untuk sambutan golf lebih lanjut.

Julia 0,5 , 30 byte

!x=[x[];x|>diff|>sort]|>cumsum

Cobalah online!

PHP, 89 byte

for($a=$argv;n|$i=$a[++$x+1];)$d[]=$i-$a[$x];for(sort($d);$x-$y++;)echo$a[1]+=$d[$y-2],_;

Jalankan seperti ini:

php -nr 'for($a=$argv;n|$i=$a[++$x+1];)$d[]=$i-$a[$x];for(sort($d);$x-$y++;)echo$a[1]+=$d[$y-2],",";' 1  5 -3  2  9;echo
> 1_-7_-3_2_9_

Penjelasan

for(
  $a=$argv;          # Set input to $a.
  n | $i=$a[++$x+1]; # Iterate over input.
)
  $d[] = $i-$a[$x];  # Add an item to array $d, with the difference between
                       the current and previous item.

for(
  sort($d);          # Sort the delta array.
  $x-$y++;           # Loop as many times as the previous loop.
)
  echo
    $a[1]+=$d[$y-2], # Print the first input item with the delta applied
                     # cumulatively. First iteration takes $d[-1], which
                     # is unset, so results in 0.
    _;               # Print underscore as separator.

Python 2 dengan numpy, 67 56 byte

from numpy import*
lambda l:cumsum(l[:1]+sorted(diff(l)))

Biarkan numpy menghitung delta, mengurutkannya, menambahkan elemen pertama, dan biarkan numpy menghitung jumlah kumulatif. Cukup murah?

Perl 6 , 31 byte

{[\+] @_[0],|sort @_[1..*]Z-@_}

Cobalah

Diperluas:

{
  [\+]            # triangle produce values using &infix<+>
    @_[0],        # starting with the first argument
    |             # slip the following into this list
      sort        # sort the following

         # generate the list of deltas

         @_[1..*] # the arguments starting with the second one
         Z[-]     # zipped using &infix:<->
         @_       # the arguments
}

Batch, 197 byte

@set n=%1
@set s=
:l
@set/ad=5000+%2-%1
@set s=%s% %d%
@shift
@if not "%2"=="" goto l
@echo %n%
@for /f %%a in ('"(for %%b in (%s%)do @echo %%b)|sort"') do @set/an+=%%a-5000&call echo %%n%%

sort tidak mengurutkan secara numerik, jadi saya bias semua perbedaan dengan 5.000.

bash + sort, 102 byte

echo $1
n=$1
shift
for e in $*
do
echo $((e-n))
n=$e
done|sort -n|while read e
do
echo $((n+=e))
done

sh + sort + expr, 106 bytes

echo $1
n=$1
shift
for e in $*
do
expr $e - $n
n=$e
done|sort -n|while read e
do
n="$n + $e"
expr $n
done

Clojure, 46 byte

#(reductions +(first %)(sort(map -(rest %)%)))

Suatu hari saya akan membuat bahasa Cljr yang memiliki nama fungsi lebih pendek dari Clojure.