给定整数列表，将以指定的顺序/深度产生正向差异。

对于整数列表：

(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字节

很容易。将depth和list作为左右参数。

-~/\~&2

作为没有所有状语欺骗手段的明确定义，这简化为

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

• -~/\~&2 y–的远期差额y。
• x -~/\~&2 y–的前x向差y。

如果我要对此功能进行认真的定义（即非定义），则可能会执行以下操作：

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

一元个案计算正向差，而二元个案计算第- x个正差。

更简单，但不完全相同：

+/\inv

+/\产生参数前缀之和的向量。inv（定义为^:_1）是使动词相反的连词。只要J知道如何对动词求逆，对于+/\J 而言，J都会知道如何对付。

Python，61 59字节

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)（如depth 3和list [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字节

MartinBü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~<       

用法：首先用深度预先填充堆栈（在python解释器中为-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是必要的，因为Prelude无法将a 0与输入的末尾区分开。输出也以换行符分隔的整数列表。我必须假设我们针对此挑战设计的经过略微调整的Prelude规范，因为标准Prelude会将整数读取为字节值，因此无法输入负数。本质上，这是带有附加标志的Python解释器NUMERIC_INPUT。

供参考，只有48 38 37个非空格字符-其余仅需要正确对齐代码。

说明

在Prelude中，每行是一个单独的“语音”，在其自己的堆栈上运行。程序逐列执行，其中单独的声音被“并行”操作。所有命令都是单个字符，括号是类似于Brainfuck的循环（只要堆栈的顶部非零，就会输入并重复）。请注意，右括号的垂直位置无关紧要-将其置于不同的音色中仍会​​与最近的右括号匹配，并且检查循环条件的堆栈始终是(出现音色的位置。现在开始这个程序...

该程序基本上可以分为两部分。底部的两行仅用于程序中的大多数循环（主循环除外N），1来回传递s。前两行包含主循环和实际差异。以下注释已转置了代码，因此我可以注释各个列：

? ?   # 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高尔夫。任何建议将不胜感激:)

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个局部变量的值减去第y个局部变量的值（即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

Japt -h，17 5字节

@Shaggy节省了12个字节

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

很简单的答案：P

Japt，7个字节

我为Luis 的解决方案提供了两个选择。

_än}gNÅ

试试吧

10字节

ÏÄ<V}f@=än

试试吧