Sortir dan Terapkan kembali Delta Array

11

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 , jadi byte-count terendah menang!
  • Selamat bersenang-senang!
ATaco
sumber
2
IMO Anda harus menghapus header kedua (yang ada di tubuh posting itu sendiri). Agak jelek dan hanya membutuhkan ruang, dan itu adalah salinan dari judul (yang seperti 20 px di atasnya).
Rɪᴋᴇʀ

Jawaban:

4

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.
Dennis
sumber
5

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
Luis Mendo
sumber
3

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

Greg Martin
sumber
3

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
Riley
sumber
Anda bisa menghemat 4 byte dengan¬=s¥{vy+=
Emigna
2

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
orlp
sumber
2

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
Nama Tampilan Umum
sumber
2
scanl(+)a$sort...
nimi
2

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.

Neil
sumber
2

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!

Keerthana Prabhakaran
sumber
Saya sedang berusaha menemukan cara untuk melakukannya seperti itu!
kuintopia
1
Anda dapat menyimpan beberapa byte dengan mengonversinya menjadi fungsi:lambda x:[sum(sorted(map(int.__sub__,x[1:],x[:-1]))[:i])+x[0]for i in range(len(x))]
ovs
1

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]
R. Kap
sumber
1

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!

tongkat
sumber
Anda dapat menghapus spasi dalam pemahaman daftar untuk 96 byte:[p[i+1]-p[i]for i in range(len(p)-1)]
sagiksp
1

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.

kuintopia
sumber
1

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.
aross
sumber
1

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?

kuintopia
sumber
1
Hemat 3 byte dengan mengubah impor ke from numpy import*dan n.cumsumke cumsumdan n.diffkediff
ov
Terima kasih. Anda bisa tahu sudah lama sejak saya bermain golf python, melupakan semua trik standar.
kuintopia
0

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
}
Brad Gilbert b2gills
sumber
0

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.

Neil
sumber
0

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
Neil
sumber
0

Clojure, 46 byte

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

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

NikoNyrh
sumber