Dường như bất kỳ đơn giản Modification của đồng bằng châu thổ sử dụng một chức năng phù hợp hầu như luôn luôn có thể được thực hiện một số khác ngắn hơn đường , Dennis . Vì vậy, giải pháp duy nhất tôi có thể tưởng tượng để làm cho việc này khó hơn, là giới thiệu một số loại chức năng không nhất quán.

Sắp xếp.

Nhiệm vụ của bạn là lấy một mảng các số nguyên, sắp xếp các đồng bằng của chúng và biên dịch lại nó để đưa ra các mảng số nguyên mới.

VÍ DỤ.

Đối với đầu vào:

1  5 -3  2  9

Nhận Deltas sau:

  4 -8  5  7

Sau đó, sắp xếp những Deltas này, mang lại:

 -8  4  5  7

Và áp dụng lại chúng, cung cấp cho:

1 -7 -3  2  9

Đầu ra đầu vào

Bạn sẽ được cung cấp một danh sách / mảng / bảng / tuple / stack / vv. số nguyên đã ký làm đầu vào thông qua bất kỳ phương thức nhập chuẩn nào.

Bạn phải xuất dữ liệu đã sửa đổi một lần nữa dưới bất kỳ hình thức có thể chấp nhận nào, theo phương pháp sắp xếp delta ở trên.

Bạn sẽ nhận được N đầu vào trong 0 < N < 10đó mỗi số nằm trong phạm vi-1000 < X < 1000

Các trường hợp thử nghiệm

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

Ghi chú

• Như đã nêu ở trên, bạn sẽ luôn nhận được ít nhất 1 đầu vào và không quá 9.
• Số đầu tiên và cuối cùng của đầu ra của bạn, sẽ luôn khớp với số đầu vào.
• Chỉ đầu ra đầu vào tiêu chuẩn được chấp nhận
• Áp dụng sơ hở tiêu chuẩn
• Đây là môn đánh gôn , vì vậy số byte thấp nhất sẽ thắng!
• Chúc vui vẻ!

Thạch , 7 byte

IṢ;@Ḣ+\

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

Làm thế nào nó hoạt động

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

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

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

Toán học, 40 byte

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

Hàm thuần túy lấy danh sách (bất kỳ thứ gì) làm đầu vào và trả về danh sách. FoldList[Plusbắt đầu bằng một số (trong trường hợp này #&@@#là phần tử đầu tiên của đầu vào) và liên tục thêm các phần tử của danh sách tự giải thích Sort@Differences@#. Điều này bắt chước hành vi của tích hợp Accumulate, nhưng số đầu tiên sẽ cần được thêm vào danh sách các khác biệt bằng tay, làm cho số byte cao hơn (theo như tôi có thể nói).

05AB1E , 9 byte

-4 cảm ơn Emigna

¬=s¥{vy+=

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

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

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

Phá vỡ:

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

Trong JavaScript, hóa ra là người chơi gôn để tính toán nghịch đảo của một mảng . Sau đó chúng được sắp xếp theo thứ tự giảm dần và trừ dần từ phần tử đầu tiên.

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

Đã lưu 6 byte khi sử dụng lambda. Cảm ơn trứng!

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

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

Phá vỡ mã,

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

Chúc mừng mã hóa!

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

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

Bình thường, 11 byte

.u+NYS.+QhQ

Điều này chỉ làm điều rõ ràng được mô tả trong tuyên bố.

Dùng thử trực tuyến

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

Gợi ý để tiếp tục chơi golf.

Julia 0,5 , 30 byte

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

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

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],_;

Chạy như thế này:

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_

Giải trình

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 với numpy, 67 56 byte

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

Hãy để numpy tính toán các đồng bằng, sắp xếp chúng, chuẩn bị phần tử đầu tiên và để numpy tính toán các khoản tiền tích lũy. Đẹp, giá rẻ?

Perl 6 , 31 byte

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

Thử nó

Mở rộng:

{
  [\+]            # 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
}

Mẻ, 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 không sắp xếp theo số, vì vậy tôi thiên vị tất cả các khác biệt bằng 5000.

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 byte

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

Một ngày nào đó tôi sẽ tạo ra ngôn ngữ Cljr có tên hàm ngắn hơn Clojure.