정수의 목록 주어진 생산 앞으로의 차이 지정된 주문 / 깊이를.

정수 목록 :

(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 또는 기능 매개 변수를 통해 이루어질 수 있습니다.

반환 할 깊이를 지정하는 정수입니다. 이것은 목록의 길이에서 1을 뺀 0입니다.

순차 차이를 계산하기위한 정수 목록

산출

출력은 STDOUT을 통해 또는 함수에 의해 리턴 될 수 있습니다.

정수 목록으로 지정된 깊이에 대한 전방 차이

규칙

이를 직접 수행하는 내장 및 타사 기능은 허용되지 않습니다.

표준 허점 제한이 적용됩니다.

최단 코드 승리

J, 15 9 7 바이트

아주 쉽게. 깊이와 목록을 왼쪽과 오른쪽 인수로 취합니다.

-~/\~&2

모든 부 사적 속임수가없는 명시 적 정의로서

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

• -~/\~&2 y–의 차액 차이 y.
• x -~/\~&2 y–의 x차음 전달 차이 y.

이 기능을 심각하게 (즉, 골프가 아닌) 정의하려면 다음과 같이해야합니다.

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

모나 딕 경우는 순차를 계산하는 반면, 2 진 경우는-차 순차를 계산합니다 x.

더 간단하지만 정확하게 동일하지는 않습니다.

+/\inv

+/\인수의 접두사 합계의 벡터를 생성합니다. inv(로 정의 됨 ^:_1)는 동사를 뒤집는 연결입니다. 이것은 J가 동사를 뒤집는 방법을 알고있는 곳에서 작동하며의 경우 +/\J는 방법을 알고 있습니다.

파이썬, 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)(즉, 깊이 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는 지정된 횟수만큼 지정된 작업을 수행하며 항상 최신 목록에서 작동합니다.

하스켈, 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이 목록에서 th 요소를 가져옵니다 .

편집 : @ Zgarb는 저장할 6 바이트를 찾았습니다. 대박!

자바 스크립트 (ES6), 52 49 바이트

map배열을 스캔하고 slice각 재귀 호출에서 첫 번째 요소를 삭제하는 데 사용 되는 간단한 재귀 함수 .

@DocMax 덕분에 3 바이트 저장 편집 , 정말 똑똑한 제안

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.";

자바, (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

Geobits 덕분에 3 바이트 : 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는 입력의 정수 수입니다. MPrelude가 0입력의 끝 을 구별 할 수있는 방법이 없기 때문에 추가 가 필요했습니다 . 출력은 또한 개행으로 구분 된 정수 목록입니다. 표준 Prelude는 정수를 바이트 값으로 읽으므로 음수를 입력 할 수 없기 때문에이 과제를 위해 고안 한 약간 조정 된 Prelude 사양을 가정 해야했습니다 . 본질적으로 이것은 추가 플래그 가있는 Python 인터프리터 입니다 NUMERIC_INPUT.

참고로 48 38 37 개의 비 공백 문자 만 있으며 나머지는 코드를 올바르게 정렬하는 데 필요했습니다.

설명

Prelude에서 각 줄은 자체 스택에서 작동하는 별도의 "음성"입니다. 프로그램은 열 단위로 실행되며 별도의 음색이 "병렬"로 작동합니다. 모든 명령은 단일 문자이며 괄호는 Brainfuck와 같은 루프입니다 (스택의 맨 위가 0이 아닌 경우마다 입력 및 반복됨). 닫는 괄호의 세로 위치는 관련이 없습니다. 다른 음성에 넣는 것은 여전히 ​​가장 최근의 여는 괄호와 일치하는 것으로 간주되며 루프 조건을 확인하는 스택은 항상 나타나는 음성 (입니다. 이제이 프로그램으로 넘어가십시오 ...

이 프로그램은 기본적으로 두 부분으로 나눌 수 있습니다. 맨 아래 두 줄은 프로그램의 대부분의 루프에 사용되며 (주 루프 오버 제외 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.

파이썬, 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

파이썬, 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)

이것이 내 첫 파이썬 골프입니다. 모든 제안을 부탁드립니다 :)

Sp3000 덕분에 5 6 바이트

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의 주소가 함수로 전달됩니다.

배열은 0으로 끝나야합니다. 배열이 편집됩니다.

예 :

#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

파워 쉘 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, ... 인 로컬 변수 목록으로 변환 한 다음 y 번째 로컬 변수의 값을 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

apt -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

클로저, 47 바이트

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

익명 함수에 대한 간단한 재귀. 인수 순서가 현재 %2보다 자주 발생하는 것처럼 교체되면 1 바이트를 저장 합니다 %.

젤리 , 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

시도 해봐