Tutarlı bir işlev kullanan deltaların herhangi bir Basit Modifikasyonu neredeyse her zaman daha kısa bir yolla yapılabilir , Dennis . Bu nedenle, bunu daha zor hale getirmeyi hayal edebildiğim tek çözüm, bir çeşit tutarsız işlev tanıtmaktır.

Sıralama.

Göreviniz bir tamsayı dizisi almak, deltalarını sıralamak ve yeni tamsayı dizisini vermek için yeniden derlemek.

ÖRNEĞİN.

Giriş için:

1  5 -3  2  9

Aşağıdaki Deltaları edinin:

  4 -8  5  7

Sonra, bu Deltaları sıralayın, Yielding:

 -8  4  5  7

Ve onları yeniden uygulayın, bu da şunları verir:

1 -7 -3  2  9

Giriş çıkış

Size bir liste / dizi / tablo / tuple / yığın / vb verilecektir. herhangi bir standart giriş yöntemi ile girdi olarak işaretli tamsayıların.

Değiştirilmiş verileri, yukarıdaki delta sıralama yöntemini izleyerek kabul edilebilir herhangi bir biçimde bir kez daha çıkarmalısınız.

0 < N < 10Her sayının aralık dahilinde olduğu yerde N girişi alırsınız-1000 < X < 1000

Test Durumları

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

notlar

• Yukarıda belirtildiği gibi, her zaman en az 1 giriş ve en fazla 9 giriş alırsınız.
• Çıktınızın ilk ve son sayısı her zaman girişin numarasıyla eşleşecektir.
• Yalnızca Standart Giriş Çıkışı kabul edilir
• Standart boşluklar geçerlidir
• Bu kod golf , bu yüzden en düşük bayt sayısı kazanır!
• İyi eğlenceler!

Jöle , 7 bayt

IṢ;@Ḣ+\

Çevrimiçi deneyin!

Nasıl çalışır

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 bayt

1)GdShYs

Çevrimiçi deneyin!

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

Mathematica, 40 bayt

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

Giriş olarak (her şeyin) bir listesini alan ve bir liste döndüren saf işlev. FoldList[Plusbir sayı ile başlar (bu durumda, #&@@#girdinin ilk öğesi) ve sürekli olarak kendini açıklayan listenin öğelerini ekler Sort@Differences@#. Bu, yerleşik davranışı taklit eder Accumulate, ancak ilk sayının elle farklar listesine eklenmesi gerekir, bu da bayt sayısını daha yüksek kılar (anlayabildiğim kadarıyla).

05AB1E , 9 bayt

-4 Emigna sayesinde

¬=s¥{vy+=

Çevrimiçi deneyin!

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

Python 2, 92 bayt

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 Bayt

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

Yıkmak:

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 bayt

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

JavaScript'te, bir Dizinin Ters Deltalarını hesaplamak daha golfçüdür . Bunlar daha sonra azalan düzende sıralanır ve kümülatif olarak ilk elemandan çıkarılır.

Python 2 ,

90 bayt

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

84 bayt

Lambda kullanarak 6 bayt tasarruf etti. OV'lara teşekkürler!

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

Çevrimiçi deneyin!

Kodu yıkmak,

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

Mutlu Kodlama!

JavaScript (ES6), 93 bayt

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

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

Çevrimiçi deneyin!

Pyth, 11 bayt

.u+NYS.+QhQ

Bu sadece açıklamada açıklanan bariz şeyi yapar.

Çevrimiçi Deneyin

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

Daha fazla golf için öneriler hoş geldiniz.

Julia 0.5 , 30 bayt

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

Çevrimiçi deneyin!

PHP, 89 bayt

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

Şu şekilde çalıştırın:

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_

açıklama

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.

Numune ile Python 2, 67 56 bayt

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

Numpy'nin deltaları hesaplamasına izin verin, sıralayın, ilk öğenin başına ekleyin ve numpy'nin kümülatif toplamları hesaplamasına izin verin. Çok ucuz?

Perl 6 , 31 bayt

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

Dene

Expanded:

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

Toplu, 197 bayt

@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 sayısal olarak sıralamıyor, bu yüzden tüm farklılıkları 5000'e kadar önyargılıyorum.

bash + sort, 102 bayt

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 + sıralama + ifade, 106 bayt

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 bayt

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

Bir gün Clojure'dan daha kısa işlev adlarına sahip Cljr dili yapacağım.