DouKaku?

using System;
class Program
{
  static void Main()
  {
    int[] xs = { 3, 1, 4, 1, 5, 9, 2, 6, 5 };
    foreach (int k in Diff(xs))
      Console.WriteLine(k);
  }
  static int[] Diff(int[] xs)
  {
    int[] diff = new int[xs.Length - 1];
    for (int i = 0; i < xs.Length - 1; ++i) diff[i] = xs[i + 1] - xs[i];
    return diff;
  }
}

(defun diff (list)
  (do ((rest list (cdr rest))
       (acc ()))
      ((null (cdr rest)) (nreverse acc))
    (push (- (cadr rest) (car rest)) acc)))

def diff(xs)
	raise ArgumentError unless xs.size >= 2 

	(0..xs.size-1-1).map{ |n|
		xs[n+1] - xs[n]
	}
end

p diff( [3, 1, 4, 1, 5, 9, 2, 6, 5] )

diff (x:[]) = []
diff (x:(y:ys)) = (:) (y-x) $ diff $ y:ys

diff([_], []).
diff([X1,X2|Xs], [D|Ds]) :-
	D is X2 - X1,
	diff([X2|Xs], Ds).

import java.util.*;

public class Sample {
    public static List<Integer> diff(List<Integer> a) {
        List<Integer> result = new ArrayList<Integer>();
        Iterator<Integer> i = a.iterator();
        int prev = i.next();
        while (i.hasNext()) {
            int next = i.next();
            result.add(next - prev);
            prev = next;
        }
        return result;
    }

    public static void main(String[] args) {
        System.out.println(diff(Arrays.asList(3, 1, 4, 1, 5, 9, 2, 6, 5)));
    }
}

sub diff { $n = shift; map { $r = $_ - $n; $n = $_; $r } @_; }

Array.prototype.diff = function() {
    for (var i = 0, l = this.length, buf = []; i < l-1; i++) {
        buf[i] = this[i+1] - this[i];
    }
    return buf;
}

alert([3, 1, 4, 1, 5, 9, 2, 6, 5].diff());

#include <iostream>
#include <iterator>
#include <algorithm>
#include <numeric>
#include <vector>

std::vector<int> diff(const std::vector<int>& in)
{
    std::vector<int> out(in.size());

    std::adjacent_difference(in.begin(), in.end(), out.begin());

    if (! out.empty()) out.erase(out.begin());

    return out;
}

int main()
{
    const int a[] = {3, 1, 4, 1, 5, 9, 2, 6, 5};

    const std::vector<int> xs(a, a + sizeof(a) / sizeof(*a));

    const std::vector<int> v = diff(xs);

    std::copy(v.begin(), v.end(), std::ostream_iterator<int>(std::cout, ", "));
}

starling f g x = f x (g x)
diff = starling (zipWith subtract) tail

use List::Util qw/reduce/;
sub diff {my @d;reduce {push @d,$b-$a; $b} @_;@d;}

def diff(xs):
    if xs:
        return [xs[i + 1] - xs[i] for i in xrange(len(xs) - 1)]
    else:
        return []

def main():
    print diff([3, 1, 4, 1, 5, 9, 2, 6, 5])

if __name__ == '__main__':
    main()

#light
let rec diff = function
    | [] -> failwith "invalid argument"
    | x::[] -> failwith "invalid argument"
    | x::x'::[] -> (x'-x)::[]
    | x::x'::xs -> (x'-x)::diff (x'::xs)

let xs = [3;1;4;1;5;9;2;6;5]

List diff := method(
    res := list()
    for(i, 0, self size - 2,
        res append(self at(i+1) - self at(i))
    )   
    return res 
)

xs := list(3, 1, 4, 1, 5, 9, 2, 6, 5]
xs diff println

(define (diff xs) (map - (cdr xs) xs))

| xs |
xs := #(3 1 4 1 5 9 2 6 5).
^xs overlappingPairsCollect: [:a :b | b - a]

#include <stdio.h>
#include <stdlib.h>
#include <glib.h>

GSList *diff(GSList *list)
{
    int p;
    GSList *ret = NULL;
    if(!g_slist_length(list)) return NULL;
    p = (int)list->data;
    while(list = g_slist_next(list)){
        ret = g_slist_append(ret, GINT_TO_POINTER((int)list->data - p));
        p = (int)list->data;
    }
    return ret;
}

GSList *list_new(int nums[], int len)
{
    int i;
    GSList *list = NULL;
    for(i=0; i<len; i++){
        list = g_slist_append(list, GINT_TO_POINTER(nums[i]));
    }
    return list;
}

int main(int argc, char *argv[])
{
    int nums[] = {3, 1, 4, 1, 5, 9, 2, 6, 5};
    GSList *list, *d, *l;
    list = list_new(nums, sizeof(nums) / sizeof(int));
    d = diff(list);
    do printf("%d\n", d->data); while(d = g_slist_next(d));
    return EXIT_SUCCESS;
}

{
	gsub(/[^0-9]/," ")
	src_size = split($0,src)

	dest_size = diff(src,dest,src_size)
	show(dest,dest_size)
}

function diff(src,dest,size,  i)
{
	for (i=1; i<size; i++) dest[i] = src[i+1] - src[i]
	return size-1
}

function show(ar,size,  i)
{
	printf "["
	for (i=1; i<size; i++) printf ar[i] ", "
	printf ar[size] "]\n"
}

sub diff {
    my ( $a, $b ) = @_;
    return if !defined($b);
    return ( $b - $a, diff( @_[ 1 .. $#_ ] ) );
}

sub diff {
    my @rv;
    push @rv, $_[$_] - $_[$_+1] for 0..$#_-1;
    return @rv;
}

(defun diff (xs)
  (mapcar #'- (cdr xs) xs))

:-module main.

main:-diff([3,1,4,1,5,9,2,6,5],R),io:outstream([print(R),nl]).

diff([_],R) :- R=[].
diff([X1,X2|Xs],R):-R=[R1|Rs],R1:=X2-X1,diff([X2|Xs],Rs).

def diff(as:List[int]):List[int] = as match {
  case a::(as@b::bs) => (b-a)::diff(as)
  case _      => Nil
}

def diff(xs:List[int]) = 
  xs.zipAll(xs.tail,0,0).map(p=>p._2-p._1).reverse.tail.reverse

javascript:(function(a,i){for(i=a.length-1;i>0;a[i]-=a[--i]);a.shift();return(a)})([3,1,4,1,5,9])

(use srfi-42)
(define (diff xs)
  (list-ec (:do ((x (car xs)) (y (cdr xs)))
                (not (null? y))
                ((car y) (cdr y)))
           (- (car y) x)))

Iterator::each_pair: method fiber {
    prev: null;
    this { prev = it; break; }
    this {
        yield prev, it;
        prev = it;
    }
}

diff: fun(iter) {
    return iter.each_pair.map(|a,b| b - a);
}

diff([3, 1, 4, 1, 5, 9, 2, 6, 5].each).to_a.p;


// 無限列のテスト
random_generator: fiber {
    while (true) {
        yield math::ceil(math::random_range(1, 10));
    }
}
diff(random_generator).take(20).to_a.p;

def diff(xs):
    return map(lambda (x,y):y-x, zip(xs[:-1], xs[1:]))

print diff([3, 1, 4, 1, 5, 9, 2, 6, 5])

def diff(a)
  a.enum_cons(2).map {|x, y| y - x }
end

diff xs = map (\(x,y) -> x - y) $ zip (tail xs) (init xs)