user
Task

Provide code that produces a list of numbers which is the   nth  order forward difference, given a non-negative integer (specifying the order) and a list of numbers.

The first-order forward difference of a list of numbers   **A**   is a new list   **B**,   where   **B**n = **A**n+1 - **A**n.

List   **B**   should have one fewer element as a result.

The second-order forward difference of   **A**   will be:

```
tdefmodule Diff do
	def forward(arr,i\\1) do
		forward(arr,[],i)
	end

	def forward([_|[]],diffs,i) do
		if i == 1 do
			IO.inspect diffs
		else 
			forward(diffs,[],i-1)
		end
	end

	def forward([val1|[val2|vals]],diffs,i) do
		forward([val2|vals],diffs++[val2-val1],i) 
	end
end 

```

The same as the first-order forward difference of   **B**.

That new list will have two fewer elements than   **A**   and one less than   **B**.

The goal of this task is to repeat this process up to the desired order.

For a more formal description, see the related   Mathworld article.

Algorithmic options

* Iterate through all previous forward differences and re-calculate a new array each time.
* Use this formula (from Wikipedia):

:   :   :   Δ

            n
            [
            f
            ]
            (
            x
            )
            =

            ∑

            k
            =
            0

            n

            (

            n
            k

            )
            (
            −
            1

            )

            n
            −
            k
            f
            (
            x
            +
            k
            )
            {\displaystyle {\displaystyle \Delta ^{n}[f](x)=\sum \_{k=0}^{n}{n \choose k}(-1)^{n-k}f(x+k)}}

:   :   :   (Pascal's Triangle   may be useful for this option.)
assistant
(formerly Perl 6)

**Works with**: Rakudo Star version 2010-07

Here we use signature matching to bind both an entire array and a version missing the head.
The Z- operator is a zip metaoperator with a minus to subtract the two lists pairwise.
It's almost a shame to define difn, since the series and subscript are hardly longer than the call itself would be, and arguably more self-documenting than the name of the function would be.

```
sub dif(@array [$, *@tail]) { @tail Z- @array }
sub difn($array, $n) { ($array, &dif ... *)[$n] }

```