일관된 기능을 사용하는 델타의 간단한 수정 은 거의 항상 다른 짧은 방법 인 데니스 (Dennis) 로 수행 될 수있는 것으로 보인다 . 따라서 이것을 더 어렵게 만드는 유일한 해결책은 일종의 일관성없는 기능을 도입하는 것입니다.

정렬.

당신의 임무는 정수 배열을 가져 와서 델타를 정렬하고 새로운 정수 배열을 제공하기 위해 다시 컴파일하는 것입니다.

EG.

입력의 경우 :

1  5 -3  2  9

다음 델타를 받으십시오.

  4 -8  5  7

그런 다음이 델타를 정렬하십시오.

 -8  4  5  7

다시 적용하면 다음과 같은 결과가 나타납니다.

1 -7 -3  2  9

입출력

리스트 / 배열 / 테이블 / 튜플 / 스택 / 등이 제공됩니다. 표준 입력 방법을 통해 입력 된 부호있는 정수

위의 델타 정렬 방법에 따라 수정 된 데이터를 적절한 형식으로 다시 출력해야합니다.

0 < N < 10각 숫자가 범위 내에있는 N 개의 입력을받습니다.-1000 < X < 1000

테스트 사례

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

메모

• 위에서 언급했듯이 항상 최소 1 개의 입력을 받고 9를 넘지 않아야합니다.
• 출력의 첫 번째와 마지막 숫자는 항상 입력의 숫자와 일치합니다.
• 표준 입력 출력 만 허용
• 표준 허점 적용
• 이것은 code-golf 이므로 가장 낮은 바이트 수가 이깁니다!
• 즐기세요!

젤리 , 7 바이트

IṢ;@Ḣ+\

온라인으로 사용해보십시오!

작동 원리

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 바이트

1)GdShYs

온라인으로 사용해보십시오!

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

Mathematica, 40 바이트

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

(무엇이든) 목록을 입력으로 받아 목록을 반환하는 순수한 함수. FoldList[Plus는 숫자 (이 경우 #&@@#입력의 첫 번째 요소)로 시작하고 자체 설명 목록의 요소를 반복적으로 추가합니다 Sort@Differences@#. 이것은 내장 함수의 동작을 모방 Accumulate하지만 첫 번째 숫자는 차이점 목록 앞에 추가해야하므로 바이트 수를 늘릴 수 있습니다 (알 수있는 한).

05AB1E , 9 바이트

Emigna 덕분에 -4

¬=s¥{vy+=

온라인으로 사용해보십시오!

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

파이썬 2, 92 바이트

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

하스켈, 59 바이트

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

고장:

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

자바 스크립트 (ES6), 68 바이트

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

JavaScript에서는 배열 의 역 델타 를 계산하는 것이 골퍼로 밝혀졌습니다 . 그런 다음 이들은 내림차순으로 정렬되어 첫 번째 요소에서 누적 적으로 뺍니다.

파이썬 2 ,

90 바이트

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

84 바이트

람다를 사용하여 6 바이트를 절약했습니다. ovs 덕분에!

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

온라인으로 사용해보십시오!

코드를 분석하면

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

행복한 코딩!

자바 스크립트 (ES6), 93 바이트

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

파이썬 2 , 97 바이트

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

온라인으로 사용해보십시오!

Pyth, 11 바이트

.u+NYS.+QhQ

이것은 성명서에 설명 된 명백한 일을합니다.

온라인 시도

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

추가 골프 환영을위한 제안.

Julia 0.5 , 30 바이트

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

온라인으로 사용해보십시오!

PHP, 89 바이트

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

다음과 같이 실행하십시오.

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_

설명

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.

numpy, 67 56 바이트의 Python 2

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

numpy가 델타를 계산하고, 정렬하고, 첫 번째 요소를 앞에 붙이고, numpy가 누적 합계를 계산하게하십시오. 꽤 싸나요?

펄 6 , 31 바이트

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

시도 해봐

넓히는:

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

배치, 197 바이트

@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 숫자로 정렬하지 않으므로 모든 차이를 5000 씩 바이어스합니다.

bash + sort, 102 바이트

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 + 정렬 + expr, 106 바이트

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

클로저, 46 바이트

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

언젠가 Clojure보다 짧은 기능 명을 가진 Cljr 언어를 만들려고합니다.