배열의 역 델타

당신의 임무는 부호있는 32 비트 정수의 배열이 주어지면 역 델타로 다시 컴파일하는 것입니다. 예를 들어, 목록

1  3  4  2  8

델타를 보유합니다.

  2  1 -2  6

그런 다음 무효화되어 다음을 산출합니다.

 -2 -1  2 -6

다시 컴파일하여 다음을 산출했습니다.

1 -1 -2  0 -6

최종 결과로.

입출력

리스트 / 배열 / 테이블 / 튜플 / 스택 / 등이 제공됩니다. 표준 입력 방법을 통해 입력 된 부호있는 정수

위의 델타 반전 방법에 따라 수정 된 데이터를 허용 가능한 형식으로 다시 출력해야합니다.

0 < N < 10각 숫자가 범위 내에있는 N 개의 입력을받습니다.-1000 < X < 1000

테스트 사례

5 6 7 8          -> 5 4 3 2
1 3 4 2 8        -> 1 -1 -2 0 -6
32 18 25 192 199 -> 32 46 39 -128 -135

노트

• 델타 기반 방법으로 제한되지 않습니다. 더 쉬운 방법 (너무 힘들지 않아야 함) 을 해결할 수 있다면 자유롭게 사용할 수 있습니다.
• 위에서 언급했듯이 항상 최소 1 개의 입력을 받고 9를 넘지 않아야합니다.
• 출력의 첫 번째 숫자는 항상 입력의 첫 번째 숫자 여야합니다. 그렇지 않은 경우 방법이 올바르지 않습니다.
• 표준 입력 출력 만 허용
• 표준 허점 적용
• 이것은 code-golf 이므로 가장 낮은 바이트 수가 이깁니다!
• 즐기세요!

우리는 승자가 있습니다.

Tiny 3 Bytes 의 Dennis 's Jelly Answer 는 내가 이길 수 없다는 인상을 받고 있기 때문에 금을 집으로 가져 왔습니다.

나는 원래의 사양을 바탕으로 답변을 얻지 못했지만 약간 실망했지만 나중에는 현상금을 정확하게 입힐 수 있습니다.

젤리 , 7 3 바이트

ḤḢ_

온라인으로 사용해보십시오!

배경

(a, b, c, d) 의 델타 는 b-a , c-b 및 d-c 입니다. 감산에 의해 (a, b-a, c-b, d-c) 를 누적 감소 시키면 a- (b-a) = 2a-b , 2a-b-(c-b) = 2a-c 및 2a-c -(d-c) = 2a-d 이므로 올바른 결과는 (2a-a, 2a-b, 2a-c, 2a-d) 입니다.

작동 원리

ḤḢ_  Main link. Argument: A (array)

Ḥ    Unhalve; multiply all integers in A by 2.
 Ḣ   Head; extract first element of 2A.
  _  Subtract the elements of A from the result.

파이썬 2, 30 바이트

lambda x:[x[0]*2-n for n in x]

Ideone에서 테스트하십시오 .

작동 원리

(a, b, c, d) 의 델타 는 b-a , c-b 및 d-c 입니다. 감산에 의해 (a, b-a, c-b, d-c) 를 누적 감소 시키면 a- (b-a) = 2a-b , 2a-b-(c-b) = 2a-c 및 2a-c -(d-c) = 2a-d 이므로 올바른 결과는 (2a-a, 2a-b, 2a-c, 2a-d) 입니다.

수학, 8 바이트

2#-{##}&

불명확 한 수의 인수를 취하는 이름없는 함수. 이것은 "쉬운"방식을 사용합니다. 전체 목록을 무시하고 (원래) 첫 번째 요소의 두 배를 추가합니다.

예를 들어 2#-{##}&[1,3,4,2,8]; 와 같은 목록을 반환합니다 {1,-1,-2,0,-6}.

자바 스크립트 (ES6), 21

Thx @ 데니스

l=>l.map(v=>l[0]*2-v)

05AB1E , 4 바이트

¬·s-

온라인으로 사용해보십시오! 또는 테스트 스위트

설명

¬     # head of input list
 ·    # multiplied by 2
  s   # swap with input list
   -  # subtract

파이썬, 44 바이트

lambda l:[l[0]]+[x-(x-l[0])*2for x in l[1:]]

이것은 "쉬운 방법"을 사용합니다.

Pyth, 5 바이트

-LyhQ

온라인 통역사!

R, 23 18 17 바이트

x=scan();2*x[1]-x

자동 벡터화 및 기본 인쇄 구조!

루비, 23 바이트

->l{l.map{|x|l[0]*2-x}}

특히 독창적이지 않습니다.

펄 6 ,  40  16 바이트

{[\+] .[0],|.rotor(2=>-1).map({[-] @_})}

{.map(.[0]*2-*)}

넓히는:

{ # bare block lambda with single implicit parameter ｢$_｣ ( input is a List )

  [\[+]]  # triangle reduce the following using ｢&infix:<+>｣

    .[0], # the first value

    |(    # Slip this list into outer one ( Perl 6 doesn't auto flatten )

      .rotor( 2 => -1 ) # take the input 2 at a time, backing up 1
      .map({ [-] @_ })  # reduce the pairs using ｢&infix:<->｣

    )
}

{ # bare block lambda with single implicit parameter ｢$_｣ ( input is a List )

  .map(          # map over the inputs
    .[0] * 2 - * # take the first value multiply by 2 and subtract the current value
    #          ^- this makes the statement a WhateverCode, and is the input
  )
}

브레인 플락 , 76 바이트

([][()]){{}(({})<(({}){}[{}]<>)<>>)([][()])}{}({}<<>([]){{}({}<>)<>([])}<>>)

온라인으로 사용해보십시오!

설명:

Part 1:
(      )                                        # Push:
 []                                             # the height of the stack
   [()]                                         # minus 1
        {                                  }    # While the height - 1 != 0:
         {}                                     # Pop the height
           (({})<                               # Hold onto the top value, but put it back.
                                                # This ensures that the top value is always
                                                # what was the first element of input
                 (            )                 # Push:
                  ({}){}                        # Top * 2
                        [{}]                    # minus the next element
                            <> <>               # onto the other stack

                                 >)             # Put back the element we held onto.
                                   (      )     # Push:
                                    []          # The height of the stack
                                      [()]      # Minus 1  
                                            {}  # Pop the counter used for the height
Part 2:
({}<                                            # Hold onto the top element.
                                                # This was the first number for input
                                                # so it needs to end up on top
    <>                                          # Switch stacks
      ([])                                      # Push the height of the stack
          {              }                      # While the height != 0:
           {}                                   # Pop the height
             (    )                             # Push:
              {}                                # The top element of this stack
                <>                              # onto the other stack
                   <>                           # and switch back
                     ([])                       # Push the new height of the stack
                          <>                    # After every element has switched stacks
                                                # (which reverses their order),
                                                # switch stacks
                            >)                  # Push the first element back on

하스켈, 20 19 바이트

f(x:r)=x:map(2*x-)r

Dennis와 같은 솔루션입니다. 2a - x . .

Christian Severs 덕분에 1 바이트를 절약했습니다.

파이크, 5 4 바이트

h}m-

여기 사용해보십시오!

PHP, 48 바이트

for(;''<$c=$argv[++$i];)echo-$c+2*$a=$a??$c,' ';

Dennis의 기술을 사용합니다. 다음과 같이 사용하십시오.

php -r "for(;''<$c=$argv[++$i];)echo-$c+2*$a=$a??$c,' ';" 1 3 4 2 8

비 Dennis 55 바이트 버전 :

for(;''<$c=$argv[++$i];$l=$c)echo$a+=($l??$c*2)-$c,' ';

APL, 8 바이트

+\⊃,2-/+

설명:

+\           ⍝ running sum of
  ⊃          ⍝ first item of list
   ,         ⍝ followed by
    2-/      ⍝ differences between every pair in
       +     ⍝ input list

테스트 사례 :

      ( +\⊃,2-/+ ) ¨ (5 6 7 8) (1 3 4 2 8) (32 18 25 192 199)
┌───────┬────────────┬──────────────────┐
│5 4 3 2│1 ¯1 ¯2 0 ¯6│32 46 39 ¯128 ¯135│
└───────┴────────────┴──────────────────┘

미로 , 34 바이트

?:_2*}
@    _
)\?_1"
,    ;
!`-}:{

온라인으로 사용해보십시오!

@Dennis 의 (2a - a, 2a - b, 2a - c, 2a - d)접근 방식을 사용합니다 .

노란색 타일은 제어 흐름을위한 것입니다. 이 2D 프로그래밍 언어에서 프로그램은 동쪽으로 이동하여 가장 왼쪽 상단에서 시작하여 시작됩니다. 정션에서 방향은 기본 스택 상단의 부호로 결정됩니다. 빈 타일은 벽입니다.

초록

이 섹션은 2a를 보조 스택에 저장합니다.

• ? 첫 번째 숫자를 가져 와서 기본 스택 맨 위로 밀어
• : 스택 상단 복제
• _2 스택 상단으로 2 개 밀어
• *팝 y, 팝 x, 푸시x*y
• } 기본 스택의 상단을 보조 스택의 상단으로 이동하십시오.
• _ 스택 상단으로 0을 밉니다

주황색

이 섹션은 현재 숫자에서 2a를 빼고 결과를 무시하고 결과를 출력하며 다음 문자 (델리 미터)를 얻거나 EOF 인 경우 종료하고 개행을 출력하고 다음 숫자를 얻습니다.

• "op 북쪽에서 오면 스택 맨 위가 0이되고 프로그램은 남쪽으로 계속됩니다. 서쪽에서 오면 스택의 맨 위가 하나가되고 프로그램이 오른쪽으로 회전합니다 (남쪽으로 계속).
• ;스택 상단을 폐기하십시오. 0 또는 1은 제어 흐름에만 사용되므로이를 무시해야합니다.
• { 보조 스택 상단 (2a)을 기본 스택 상단으로 이동
• : 메인 스택의 상단을 복제
• } 메인 스택의 상단을 보조 스택의 상단으로 이동
• -팝 y, 팝 x, 푸시x-y
• \`` Negate the top of the stack. This and the previous three operations have the effect of-(x-2a) = 2a-x`
• ! 스택의 상단을 팝하여 숫자로 출력
• , EOF 인 경우 다음 문자 (구분자가 됨) 또는 음수 문자를 누릅니다.
• )스택 상단을 증가시킵니다. 마지막 문자가 EOF이면 이제 스택 맨 위가 0이되고 프로그램은 바로 계속 진행 @하고 종료합니다. 마지막 문자가 델리 미터 (deimeter) 인 경우 스택의 맨 위가 양수 (positive)가되어 프로그램이 우회전하여 동쪽으로 계속됩니다.\
• \ 개행 출력
• ? 다음 전화 번호 받기
• _1 정션에서 우회전하려면 스택 상단으로 1 개를 미십시오.

미로 , 24 바이트

+:}:?
}
<}}?;%):,\!-{:{>

입력 및 출력 형식은 줄 바꿈으로 구분 된 목록입니다 (입력 형식은 실제로 훨씬 유연하지만). 프로그램이 오류와 함께 종료됩니다.

온라인으로 사용해보십시오!

이 바이트 수에는 다른 두 가지 솔루션이 있습니다.이 솔루션은 기본적으로 동일하지만 다소 다른 제어 흐름을 사용합니다.

:+:}:?
{
,}-!
?  {
:";\@

{:+:}:?
_
<>__-?:;%):,\!

설명

명령어 포인터 (IP)는 첫 번째 줄을 따라 동쪽으로 이동하기 시작하지만 ?, 우리는 어디에서나 스택 깊이 명령을 사용하지 않기 때문에 기본적으로 전역 상태에서 모든 명령이 작동하지 않습니다. 따라서 코드는 실제로? 서쪽으로 합니다. IP가 막 다른 골목에 닿으면 돌아 서기 때문입니다.

따라서 코드는 다음과 같은 선형 비트 코드로 시작합니다.

?:}:+}

이것은 단순히 공식 2a을 사용하기 위해 사본을 설정합니다 [2a - a, 2a - b, 2a - c, ...].

?   Read first integer a.
:}  Move a copy off to the auxiliary stack.
:+  Multiply a by 2 (by adding it to itself).
}   Move that off to the auxiliary stack as well.

이제 한 줄의 코드를 반복하는 표준 트릭을 사용하여 프로그램의 기본 루프에 들어갑니다.

<...>

적중 할 때마다 스택이 비워 <지므로 0을 얻습니다. 그런 <다음 전체 줄을 왼쪽으로 회전시켜 IP를 가져 와서 다음과 같이 얻습니다.

...><

그런 다음 IP는 왼쪽으로 이동해야합니다. 여기서 >줄을 원래 위치로 되돌려 놓습니다 (다음 반복을 위해 준비). 그런 다음 줄은 단순히 오른쪽에서 왼쪽으로 실행되므로 단일 루프 반복은 다음과 같습니다.

{:{-!\,:)%;?}}

Labyrinth는 코드를 건너 뛸 수있는 방법이 없기 때문에이 유형의 루프로 작업 할 때 어떤 형태의 조건부 실행 작업도 수행 할 수 없습니다. 따라서 EOF에 도달하면 0으로 나누기로 프로그램을 종료합니다. 각 루프 반복에 대한 분석은 다음과 같습니다.

{:   Pull 2a back to the main stack and make a copy.
{    Pull the latest value i of the input list back to main as well.
-    Compute 2a-i/
!\   Print it with a trailing linefeed.
,    Read a character. If there are input elements left, this will be some
     form of separator character, and therefore a positive value x. However,
     at the end of the program, this will give -1.
:)   Make an incremented copy.
%    Try to to compute x%(x+1). This will error out at EOF.
;    Discard the result of the division.
?    Read the next input value.
}}   Move that and the remaining copy of 2a back to the auxiliary stack.

C ++ 14, 36 바이트

이름을 바꾸지 않은 람다는 입력을 수정합니다.

[](auto&c){for(auto&x:c)x=2*c[0]-x;}

Dennis의 기술을 사용합니다. int[]또는 같은 컨테이너에 적용vector<int> .

용법:

#include<iostream>

auto f=
[](auto&c){for(auto&x:c)x=2*c[0]-x;}
;

int main(){
  int a[] = {1,  3,  4,  2,  8};
  f(a);
  for(auto&x:a)
    std::cout << x << ", ";
  std::cout<<"\n";
}

CJam, 16 바이트

입력 형식 : [1 2 3 4]. 쉬운 공식을 사용합니다.

l~_(2*/;a/,@@*.-

설명:

l~_(2*/;a/,@@*.-
l~_                     e#Read input twice into an array. Stack: [1 2 3 4] [1 2 3 4]
   (                    e#Get first element of the array. Stack: [1 2 3 4] [2 3 4] 1
    2*                  e#Multiply by two. Stack: [1 2 3 4] [2 3 4] 2
      /;                e#Discard second element. Stack: [1 2 3 4] 2
        a               e#Wrap into an array. Stack: [1 2 3 4] [2]
         /,             e#Rotate and get length. Stack: [2] [1 2 3 4] 4
           @@           e#Rotate twice. Stack: [1 2 3 4] 4 [2]
            *           e#Repeat len times. Stack: [1 2 3 4] [2 2 2 2]
             .-         e#Vectorized substraction. Stack: [-1 0 1 2]
                        e#Implictly print

테스트 링크가 없어 죄송합니다. SE는 내부에 괄호가있는 링크를 좋아하지 않는 것 같습니다.

Pushy , 9 바이트

{&}2*K~-_

cmd 행에서 인수를 쉼표로 구분 된 값으로 제공하십시오 $ pushy invdeltas.pshy 1,3,4,2,8. 다음은 스택 예제입니다.

           % Implicit: Input on stack              [1, 3, 4, 2, 8]
{&}        % Copy first item, put at end of stack  [1, 3, 4, 2, 8, 1]
   2*      % Multiply by 2                         [1, 3, 4, 2, 8, 2]
     K~    % Negate everything on stack            [-1, -3, -4, -2, -8, -2]
       -   % Subtract last item from all           [1, -1, -2, 0, -6]
        _  % Print whole stack

참고 : 역방향 출력이 허용되는 경우 8 바이트 일 수 있습니다. @&2*K~-_

Perl, 26 + 3 ( -pla플래그) = 29 바이트

$_="@{[map$F[0]*2-$_,@F]}"

또는

$_=join$",map$F[0]*2-$_,@F

사용 :

perl -plae '$_="@{[map$F[0]*2-$_,@F]}"' <<< "32 18 25 192 199"

Dyalog APL , 5 바이트

-+2×⊃

이것은 5 트레인으로, 중첩 된 3 트레인 ( "포크")처럼 구문 분석됩니다. -+(2×⊃)

-전체 배열 의 부정 ( )과 첫 번째 요소 ( )를 +두 번 ( 2×) 두 번 ( )으로 읽는다.⊃

ised, 11 바이트

2*$1_0-$1

기도: ised --l 'file with input.txt' '2*$1_0-$1

(편집 : Dennis에서 대수를 훔쳐서 수정)

Wonder , 17 바이트

@->#@- *2:0#1#0#0

내가 왜 이것을 이전에 게시하지 않았는지 잘 모르겠습니다. 용법:

(@->#@- *2:0#1#0#0)[5 6 7 8]

더 읽기 쉬운 :

@(map @
  - (
    * 2 get 0 #1
  ) #0
) #0