มันดูเหมือนว่าใด ๆที่เรียบง่าย การปรับเปลี่ยนของสันดอนโดยใช้ฟังก์ชั่นที่สอดคล้องกันมักจะสามารถทำได้อื่น ๆสั้น ทาง , เดนนิส ดังนั้นทางออกเดียวที่ฉันจินตนาการได้ว่าจะทำให้ยากขึ้นคือการแนะนำฟังก์ชั่นบางอย่างที่ไม่สอดคล้องกัน

การเรียงลำดับ

งานของคุณคือการใช้อาร์เรย์ของจำนวนเต็มเรียงลำดับเดลตาของพวกเขาและคอมไพล์ใหม่เพื่อให้อาร์เรย์ของจำนวนเต็มใหม่

เช่น.

สำหรับอินพุต:

1  5 -3  2  9

รับ Deltas ต่อไปนี้:

  4 -8  5  7

จากนั้นจัดเรียงเดลตาเหล่านี้ให้ผล:

 -8  4  5  7

และนำไปใช้ใหม่ซึ่งให้:

1 -7 -3  2  9

Input / Output

คุณจะได้รับรายการ / อาร์เรย์ / ตาราง / tuple / stack / etc จำนวนเต็มที่ลงนามเป็น input ผ่านวิธีการป้อนข้อมูลมาตรฐานใด ๆ

คุณต้องส่งออกข้อมูลที่ถูกแก้ไขอีกครั้งในรูปแบบที่ยอมรับได้ใด ๆ ตามวิธีการเรียงลำดับเดลต้าข้างต้น

คุณจะได้รับอินพุต N 0 < N < 10ซึ่งแต่ละหมายเลขอยู่ในช่วงที่กำหนด-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@#]&

ฟังก์ชั่นบริสุทธิ์การบันทึก (anythings) เป็นอินพุตและส่งคืนรายการ FoldList[Plusเริ่มต้นด้วยหมายเลข (ในกรณีนี้#&@@#, องค์ประกอบแรกของการป้อนข้อมูล) และซ้ำ ๆ Sort@Differences@#เพิ่มองค์ประกอบของรายการด้วยตนเองอธิบาย นี่เป็นการเลียนแบบพฤติกรรมของบิวด์อินAccumulateแต่หมายเลขแรกจะต้องมีการเติมในรายการความแตกต่างด้วยมือซึ่งทำให้จำนวนไบต์สูงขึ้น (เท่าที่ฉันสามารถบอกได้)

05AB1E , 9 ไบต์

-4 ต้องขอบคุณEmigna

¬=s¥{vy+=

ลองออนไลน์!

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

Python 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

Haskell, 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

JavaScript (ES6), 68 ไบต์

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

ใน JavaScript มันจะออกมาเป็น golfier การคำนวณผกผันสันดอนของอาร์เรย์ สิ่งเหล่านี้จะถูกจัดเรียงตามลำดับจากมากไปน้อยและถูกลบออกจากองค์ประกอบแรก

งูหลาม 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]

Happy Coding!

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

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

Python 2 ที่มีจำนวน67 67ไบต์

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

ให้ numpy คำนวณเดลตาจัดเรียงพวกเขาเสริมองค์ประกอบแรกและให้ numpy คำนวณผลรวมสะสม ค่อนข้างถูก

Perl 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 ไม่ได้เรียงลำดับตัวเลขดังนั้นฉันจึงมีอคติกับความแตกต่างทั้งหมด 5,000 คะแนน

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

Clojure 46 ไบต์

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

วันหนึ่งฉันจะสร้างภาษา Cljr ซึ่งมีชื่อฟังก์ชั่นสั้นกว่า Clojure