รับรายการของจำนวนเต็มผลิตความแตกต่างไปข้างหน้าตามคำสั่ง / ความลึกที่ระบุ

สำหรับรายการจำนวนเต็ม:

(10, 18, -12, 4, 8, -3, -5, 67, 9, 14)

ความแตกต่างไปข้างหน้าตามคำสั่ง / ความลึกต่างๆ ได้แก่ :

0   10,   18,  -12,    4,    8,   -3,   -5,  67,  9,  14
1      8,  -30,   16,    4,  -11,   -2,   72, -58,  5
2       -38,   46,  -12,  -15,    9,   74, -130, 63
3           84,  -58,   -3,   24,   65, -204, 193
4            -142,   55,   27,   41, -269, 397
5               197,  -28,   14, -310, 666
6                 -225,   42, -324, 976
7                    267, -366, 1300
8                      -633, 1666
9                         2299

ดังนั้นด้วยอินพุตของ

4, (10, 18, -12, 4, 8, -3, -5, 67, 9, 14)

คุณจะกลับรายการ

(-142,   55,   27,   41, -269, 397)

อินพุต

อินพุตสามารถผ่าน STDIN หรือพารามิเตอร์ฟังก์ชัน

จำนวนเต็มที่ระบุความลึกที่จะส่งคืน นี่จะเป็น 0 ตามความยาวของรายการลบ 1

รายการจำนวนเต็มเพื่อคำนวณผลต่างล่วงหน้าสำหรับ

เอาท์พุต

เอาต์พุตสามารถผ่าน STDOUT หรือส่งคืนโดยฟังก์ชัน

ความแตกต่างไปข้างหน้าสำหรับความลึกที่ระบุเป็นรายการจำนวนเต็ม

กฎระเบียบ

ไม่อนุญาตให้ใช้ฟังก์ชันบิวด์อินและบุคคลที่สามที่ทำสิ่งนี้โดยตรง

มีข้อ จำกัดช่องโหว่มาตรฐาน

รหัสที่สั้นที่สุดชนะ

J, 15 9 7 ไบต์

ง่ายมาก. รับความลึกและรายการเป็นอาร์กิวเมนต์ซ้ายและขวา

-~/\~&2

ในฐานะที่เป็นคำจำกัดความที่ชัดเจนโดยไม่มีการใช้คำวิเศษณ์ทั้งหมดสิ่งนี้จะลดลง

4 : '(2 -~/\ ])^:x y'

• -~/\~&2 y- yความแตกต่างของการส่งต่อ
• x -~/\~&2 y- เดอะแตกต่างไปข้างหน้าของx -thy

ถ้าฉันจะทำให้คำจำกัดความที่จริงจัง (i. e. non-golfed) ของฟังก์ชันนี้ฉันอาจทำสิ่งนี้:

(}. - }:) : ($:@[&0)

กรณี monadic คำนวณความแตกต่างไปข้างหน้าในขณะที่กรณี dyadic คำนวณความxแตกต่างไปข้างหน้า -th

ง่ายขึ้น แต่ไม่เท่ากัน:

+/\inv

+/\ให้ผลเวกเตอร์ของผลรวมของส่วนนำหน้าของอาร์กิวเมนต์ inv(นิยามเป็น^:_1) คือการรวมที่ inverses กริยา สิ่งนี้ใช้ได้ทุกที่ J รู้วิธีที่จะผันคำกริยาและสำหรับกรณีของ+/\J รู้วิธี

Python 61 61ไบต์

f=lambda n,L:n and f(n-1,[x-y for x,y in zip(L[1:],L)])or L

ที่นี่เราทำการลบโดยการซิปทั้งหมดยกเว้นรายการสุดท้ายด้วยทั้งหมดยกเว้นรายการแรก zip(L[1:],L)เทียบเท่าzip(L[1:],L[:-1])เนื่องจากzipลักษณะของการรับความยาวขั้นต่ำของสองรายการ:

>>> zip([1,2,3],[4,5])
[(1, 4), (2, 5)]

ทางเลือกที่ยาว (Python 2 เท่านั้น):

f=lambda n,L:n and f(n-1,map(int.__sub__,L[1:],L[:-1]))or L

น่าเสียดายที่ Python 2 ไม่ได้ตัดปลายรายการดังนั้นฉันทำไม่ได้ map(int.__sub__,L,L[1:])ไม่ได้ตัดออกจากปลายของรายการดังนั้นฉันไม่สามารถทำได้ น่ารำคาญ Python 3 ทำแต่จะmapไม่ส่งคืนรายการอีกต่อไปดังนั้นสิ่งนี้จะกลายเป็นไบต์มากกว่า (60 ไบต์):

f=lambda n,L:n and f(n-1,list(map(int.__sub__,L[1:],L)))or L

อย่างไรก็ตามหากเราอนุญาตให้อินพุตเป็นความลึกตามด้วยรายการเช่นf(3, 2, 5, 6, 7, 5, 10, 25)(ความลึก 3 และรายการ[2, 5, 6, 7, 5, 10, 25] ) ดังนั้นนี่คือ56 ไบต์ :

f=lambda n,*T:n and f(n-1,*map(int.__sub__,T[1:],T))or T

นี่เป็นอีกทางเลือกหนึ่งที่จะรบกวนใครก็ตามที่เห็นสิ่งนี้ในรหัสการผลิต (อันนี้จะทำลายรายการเดิม):

f=lambda n,L:n and f(n-1,[L[1]-L.pop(0)for _ in L[1:]])or L

Mathematica 23 57 23 ไบต์

คำแนะนำของ Martin Büttnerใช้ประโยชน์จากความสามารถในการลบ

 Rest@#-Most@#&~Nest~##&

เช่น

Rest@# - Most@# &~Nest~## & @@ {{10, 18, -12, 4, 8, -3, -5, 67, 9, 14}, 4}

{-142, 55, 27, 41, -269, 397}

Rest@#-Most@# ดำเนินการลบที่ให้ผลต่าง

Nest ดำเนินการดังกล่าวตามจำนวนครั้งที่กำหนดให้ดำเนินการกับรายการล่าสุดเสมอ

Haskell, 40 34 ไบต์

n#l=iterate(zipWith(-)=<<tail)l!!n

ตัวอย่างการใช้งาน: 4 # [10,18,-12,4,8,-3,-5,67,9,14]เอาต์พุตใด[-142,55,27,41,-269,397]ใด

มันทำงานอย่างไร: คำนวณความแตกต่างระหว่างองค์ประกอบเพื่อนบ้านและเก็บผลลัพธ์ระดับกลางในรายการซ้ำ ๆ รับnองค์ประกอบที่สามจากรายการนี้

แก้ไข: @Zgarb พบ 6 ไบต์เพื่อบันทึก ! น่ากลัว

JavaScript (ES6), 52 49 ไบต์

ฟังก์ชั่นวนซ้ำแบบง่ายโดยใช้mapเพื่อสแกนอาร์เรย์และsliceวางองค์ประกอบแรกในการเรียกซ้ำแต่ละครั้ง

บันทึกการแก้ไข 3 ไบต์ขอบคุณ @DocMax คำแนะนำที่ชาญฉลาดจริงๆ

F=(n,l)=>n?F(n-1,l.slice(1).map((a,k)=>a-l[k])):l

ทดสอบในคอนโซล Firefox / FireBug

for(i=0;i<10;i++)console.log(F(i,[10, 18, -12, 4, 8, -3, -5, 67, 9, 14]))

[10, 18, -12, 4, 8, -3, -5, 67, 9, 14]
[8, -30, 16, 4, -11, -2, 72, -58, 5]
[-38 , 46, -12, -15, 9, 74, -130, 63]
[84, -58, -3, 24, 65, -204, 193]
[-142, 55, 27, 41, -269, 397 ]
[197, -28, 14, -310, 666]
[-225, 42, -324, 976]
[267, -366, 1300]
[-633, 1666]
[2299]

CJam, 15 ไบต์

l~{{_@-\}*;]}*p

รับอินพุตเป็นอาร์เรย์สไตล์ CJam และตามความลึก:

[10 18 -12 4 8 -3 -5 67 9 14] 4

และพิมพ์ผลลัพธ์เป็นอาร์เรย์สไตล์ CJam

ทดสอบที่นี่

คำอธิบาย

l~              "Read and eval input.";
  {         }*  "Repeat this block N times, which computes the forward differences.";
   {    }*      "Fold this block onto the list - this is quite an abuse of folding semantics.";
    _           "Duplicate the current element (for the use in the next difference).";
     @          "Pull up the other copy of the last element.";
      -         "Subtract.";
       \        "Swap the difference and the other copy of the current element.";
          ;     "Discard the last element.";
           ]    "Wrap everything in an array again.";

Java, 122 119 ไบต์

int[]a(int[]a,int b){if(b<1)return a;int e=a.length-1,c[]=new int[e],i=e;for(;i-->0;)c[i]=a[i+1]-a[i];return a(c,b-1);}

ตัวอย่างการใช้งาน: http://ideone.com/ALgYez

3 ไบต์ต้องขอบคุณ Geobits: v)>

> <> 53 50 ไบต์

l:[2-&\~~]r1-:?!vr
&}-@:$/!?&:-1
:;!? &&  lo*84n~<       

การใช้งาน: เติมสแต็ก (-v ในตัวแปลหลาม) ด้วยความลึกก่อนตามด้วยจำนวนเต็ม

ตัวอย่างเช่น:

forward.fish -v 3 2 5 6 7 5 10 25

ผลตอบแทน

2 -3 10 3

ขอบคุณ Sp3000 สำหรับความช่วยเหลือ

พรีลูด , 95 92 79 78 ไบต์

?    (1-vv- # ) v  !
  ?     #   ^   #
?(1-)   1  (#)  1)(#)
  1   #(# ) 1  (#

รูปแบบอินพุตคือ

N
M
n_1
n_2
...
n_M

ที่ไหน Nความลึกของความแตกต่างและMเป็นจำนวนเต็มในอินพุต การเพิ่มMเป็นสิ่งจำเป็นเนื่องจากไม่มีวิธีใดที่โหมโรงในการแยกความแตกต่าง0จากส่วนท้ายของอินพุต เอาต์พุตยังเป็นรายการจำนวนเต็มที่คั่นด้วยบรรทัดใหม่ ฉันต้องสมมติว่าข้อมูลจำเพาะโหมโรงที่ปรับเปลี่ยนเล็กน้อยที่เราคิดค้นขึ้นสำหรับความท้าทายนี้เนื่องจากพรีลูดมาตรฐานอ่านจำนวนเต็มเป็นค่าไบต์ซึ่งทำให้ไม่สามารถป้อนจำนวนลบได้ โดยพื้นฐานแล้วนี่คือตัวแปลภาษา Pythonพร้อมกับการNUMERIC_INPUTตั้งค่าสถานะเพิ่มเติม

สำหรับการอ้างอิงมีอักขระที่ไม่ใช่ช่องว่างเพียง48 38 37 ตัวส่วนที่เหลือเป็นเพียงการจัดเรียงรหัสอย่างถูกต้อง

คำอธิบาย

ในโหมโรงแต่ละบรรทัดจะมี "เสียง" แยกต่างหากที่ทำงานบนสแต็กของตัวเอง โปรแกรมจะถูกดำเนินการแบบคอลัมน์ต่อคอลัมน์โดยที่เสียงที่แยกออกมาจะถูกใช้เพื่อทำงาน "แบบขนาน" คำสั่งทั้งหมดเป็นตัวอักษรเดียวและวงเล็บเป็นลูปเหมือน Brainfuck (ซึ่งถูกป้อนและทำซ้ำทุกครั้งที่ด้านบนสุดของสแต็กไม่ใช่ศูนย์) โปรดทราบว่าตำแหน่งแนวตั้งของวงเล็บปิดไม่เกี่ยวข้อง - การใส่ไว้ในเสียงที่แตกต่างยังคงนับเป็นการจับคู่กับวงเล็บเปิดล่าสุดและสแต็กที่ตรวจสอบสภาพลูปจะเป็นเสียงที่(ปรากฏอยู่เสมอ ไปที่โปรแกรมนี้ ...

โดยทั่วไปโปรแกรมสามารถแยกออกเป็นสองส่วน สองบรรทัดด้านล่างใช้สำหรับลูปส่วนใหญ่ในโปรแกรมเท่านั้น (ยกเว้นลูปหลักเหนือN) ผ่าน1s ไปมา สองบรรทัดบนสุดมีลูปหลักและความแตกต่างตามจริง คำอธิบายประกอบต่อไปนี้มีการเปลี่ยนรหัสดังนั้นฉันสามารถใส่คำอธิบายประกอบแต่ละคอลัมน์:

? ?   # Read two integers. Read instructions are processed top to bottom, so the first voice 
      # reads N and the third voice reads M.
  (   # Start a loop on the third voice. This loop will execute M times, reading the input list
      # and pushing M 1s onto the fourth voice - i.e. a unary representation of M.
 ?11  # Read an integer onto the second voice, push 1s onto the third and fourth voice.
  -   # Subtract the 1 from the third voice, decrementing M down to 0.
  )   # End of loop, if the third voice is not 0 yet, to back two columns.
(     # Start a loop on the first voice. This is the main loop and will execute N times. Each
      # iteration will compute the forward differences once and thereby shorten the list by one
      # element and also reduce the stack of 1s on the bottom voice by one.
1  #  # Push a 1 onto the first voice and pop a 1 from the last. Together with the next column,
      # this decrements both N and (the unary) M.
-  (  # Subtract the 1 from the first voice (decrementing N), and start a loop on the fourth 
      # voice over whatever is left of M (the length of the resulting difference list). Note 
      # that this column is *not* part of the loop, so the - on the first voice will only be 
      # executed once. This loop builds the differences in reverse order on the first voice.
v#1#  # Pop a 1 from the fourth voice and push a 1 onto the third. This loops over M while
      # shifting its unary representation to the other stack. In addition, shift the top stack
      # element from the second to the first voice.
v     # Copy the next element from the second voice to the first, without popping.
-  )  # Subtract the two elements on the first voice and end the loop if the fourth voice is 
      # empty. Note that his column *is* part of the loop.
  (   # Start a loop on the third voice. This is another loop over M, shifting the stack of 1s 
      # back to the fourth voice, and reversing the differences by shifting them onto the 
      # second.
#^#1  # As stated above, shift an element from the first to the second voice, a 1 from the
      # third to the fourth.
  )   # End the loop. After this point, we're back to the original situation, except that the
      # second voice has been replaced by its differences. The bottom stack element the
      # previous list is also still on that stack, but the decreasing loop lengths on the third
      # and fourth voices ensures that this element is never touched again.
)     # End the main loop when N has been reduced to 0.
   (  # Start another loop over the remaining list length, shifting and reversing the result.
v#1#  # Shift a 1 back to the third voice and an element from the second to the first voice.
  )   # End the loop. Note that this parenthesis is not on the same voice as the corresponding
      # opening parenthesis, but its exact position is irrelevant. Moving it to this voice
      # saves a byte.
  (   # Start one last loop over the length of the result.
! #   # Pop a 1 from the third voice while printing (and popping) one element of the result.
  )   # End the loop.

Python, 70 68 67 59 ไบต์

f=lambda x,n:n and f([x[1]-x.pop(0)for i in x[1:]],n-1)or x

เวอร์ชันที่ไม่ใช่กอล์ฟก่อนที่ฉันจะเรียกซ้ำ:

def f(x,n):
    for j in range(n):
        for i in range(len(x)-1):
            x[i]=x[i+1]-x[i]
    return x[:-n]

R, 48 39 46 44 ไบต์

เรียกซ้ำ!

function(x,y)if(x)Recall(x-1,diff(y)) else y

• x คือจำนวนการทำซ้ำที่ต้องดำเนินการและ yเป็นเวกเตอร์ของจำนวนเต็ม
• if(x) เป็นจริงตราบใด x>0ใด
• Recall เรียกใช้ฟังก์ชันปัจจุบัน แต่มีอาร์กิวเมนต์ใหม่
• Diff แสดงความแตกต่างระหว่างองค์ประกอบรายการ / เวกเตอร์ที่ต่อเนื่องกัน

รุ่นก่อนหน้า:

#does not work for x=0:
function(x,y){for(i in 1:x)y=diff(y);y}

#does not use diff function:
function(x,y){for(i in 1:x)y=y[-1]-head(y,-1);y}

y[-1]       is a list minus its first element
head(y,-1)  is a list minus its last element

Python, 92 87 86 ไบต์

def a(b,c):
 if c<1:return b
 d=[];e=b[0]
 for f in b[1:]:d+=f-e,;e=f
 return a(d,c-1)

นี่คือ Python Golf ตัวแรกของฉัน ข้อเสนอแนะใด ๆ จะได้รับการชื่นชม :)

5 6 ไบต์ขอบคุณ Sp3000: D

c, 68 55 ไบต์

f(int *l){for(--l[-1]?f(l):0;*l;l++)*l=l[1]-*l;*--l=0;}

นี่อาจเป็นเรื่องของเสรีภาพด้วยข้อมูลจำเพาะของอินพุต อาร์เรย์ int ถูกสร้างขึ้นโดยที่องค์ประกอบ 0 คือความลึกและองค์ประกอบที่ 1 ถึง (n + 1) คือองค์ประกอบรายการอินพุต 0 ถึง n จากนั้นที่อยู่ขององค์ประกอบ 1 จะถูกส่งผ่านไปยังฟังก์ชัน

อาร์เรย์จะต้องถูกยกเลิกเป็นศูนย์ มีการแก้ไขอาร์เรย์ในสถานที่

เช่น:

#include <stdio.h>

f(int *l){for(--l[-1]?f(l):0;*l;l++)*l=l[1]-*l;*--l=0;}

int main (int argc, char **argv)
{
  int list[] = {4, 10, 18, -12, 4, 8, -3, -5, 67, 9, 14, 0};
  int *elem;

  f(list + 1);

  for (elem = list + 1; *elem; elem++) {
    printf("%d, ", *elem);
  }
}

http://ideone.com/m5PDgF

Powershell 115 111 ไบต์

$p={param($a, $b)0..($a-1)|%{$b=@($l=$b.length;for($i=0;$i-lt$l;$i++){$b[$i+1]-$b[$i]})[0..($l-2)]};$b-join','}

ดำเนินการเช่นนี้:

.$p 4 @(10,18,-12,4,8,-3,-5,67,9,14)

เอาท์พุท:

-142,55,27,41,-269,397

การขยับรั้งเป็นลอนไปยังจุดที่แตกต่างกันทำให้สามารถแสดงคำตอบทุกขั้นตอนได้

8,-30,16,4,-11,-2,72,-58,5
-38,46,-12,-15,9,74,-130,63
84,-58,-3,24,65,-204,193
-142,55,27,41,-269,397

STATA, 126 ไบต์

di _r(a)_r(b)
token $b
gl $c=wordcount($b)
forv x=1/$a{
gl $c--
forv y=1/$c{
loc `y'=``y'+1'-``y''
}
}
forv z=1/$c{
di ``z''
}

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

ก่อนอื่นมันจะแปลงรายการจำนวนเต็ม (ซึ่งมันดูเป็นสตริงที่มีความยาว 1 รายการ) เป็นรายการของตัวแปรท้องถิ่นที่มีชื่อเป็น 1,2,3, ... จากนั้นจะคำนวณความแตกต่างไปข้างหน้าโดยการตั้งค่าของตัวแปรท้องถิ่น yth ให้เป็น ค่าของตัวแปรโลคัล y + 1 ลบค่าของตัวแปรโลคัล yth (เช่น 18-10 = 8) ซึ่งจะเขียนทับค่าที่มีอยู่หลังการใช้งานเท่านั้น มันทำเช่นนี้ $ a (มูลค่าของตัวแปรทั่วโลก a) คูณ จากนั้นจะแสดงค่าของตัวแปรโลคัลแต่ละตัวครั้งละ 1 ตัว

T-SQL มากเกินไป :)

เมื่อฉันแรกเห็นปัญหานี้ฉันสงสัยว่ามีวิธีการทำเช่นนี้ในแบบสอบถาม ในขณะที่เรื่องเล็กน้อยสำหรับภาษาส่วนใหญ่ก็ไม่มากสำหรับแบบสอบถาม SQL

อินพุตจะเข้าสู่ตัวแปร @ (สำหรับความลึก) และ @L สำหรับรายการจำนวนเต็ม @L เป็นประเภทตารางที่ผู้ใช้กำหนด

CREATE TYPE L AS TABLE(n INT IDENTITY(0,1),v INT)

การตั้งค่าอินพุต

DECLARE @L L,@ INT=4
INSERT @L(v)values(10),(18),(-12),(4),(8),(-3),(-5),(67),(9),(14)

แบบสอบถามที่มีความคิดเห็น

WITH R AS( 
    -- Recursive query to calculate the level of a pascal triangle with alternating negatives
    -- For 4 this is 1 -4  6 -4  1  
    SELECT 1c,0g UNION ALL SELECT-c*(@-g)/(g+1),g+1FROM r WHERE g<@
    ),
    O AS( 
    --Multiple N values of list by reversed pascal triangle values
    --shifting the start for each iteration (list length) - N
    SELECT c*v v,F 
    FROM @L L 
        CROSS APPLY(
            SELECT TOP((SELECT COUNT(*)FROM @L)-@)ROW_NUMBER()OVER(ORDER BY(SELECT\))-1F FROM sys.all_views a,sys.all_views b)c 
        JOIN R ON N=F+@-G
    )
-- Sum the multiplied values
SELECT SUM(V)FROM o GROUP BY F ORDER BY F

ผล

-142
55
27
41
-269
397

Japtap -h , 17 5 ไบต์

บันทึก 12 ไบต์ด้วย @Shaggy

VÆ=än

ลองออนไลน์!

SmileBASIC ขนาด 76 ไบต์

ในที่สุดเหตุผลที่จะใช้ARYOP!

DEF F L,D
IF!D THEN@R
DIM B[0]COPY B,L
T=SHIFT(L)ARYOP 1,L,L,B
F L,D-1@R
END

Clojure, 47 ไบต์

#(if(= 0 %)%2(recur(dec %)(map -(rest %2)%2))))

การเรียกซ้ำแบบง่ายบนฟังก์ชันที่ไม่ระบุชื่อ คุณประหยัด 1 ไบต์ถ้าสั่งของการขัดแย้งจะสลับเป็นตอนนี้เกิดขึ้นบ่อยครั้งกว่า%2%

เยลลี่ 2 ไบต์

I¡

ลองออนไลน์!

คำอธิบาย

I¡  Main Link
 ¡  Repeat `n` times; this repeats the previous link by <right argument> times
I   Get forward differences

คำตอบที่ตรงไปตรงมามาก: หน้า

Japtap , 7 ไบต์

คู่ของทางเลือกฉันพร้อมที่จะทำให้หลุยส์สำหรับการแก้ปัญหาของเขา

_än}gNÅ

ลองมัน

10 ไบต์

ÏÄ<V}f@=än

ลองมัน