配列の逆デルタ

あなたの仕事は、符号付き32ビット整数の配列が与えられたら、その逆デルタで再コンパイルすることです。たとえば、リスト

1  3  4  2  8

デルタを保持します：

  2  1 -2  6

これらは無効になり、次のようになります。

 -2 -1  2 -6

そして、再コンパイルして、次を生成します。

1 -1 -2  0 -6

最終結果として。

入出力

list / array / table / tuple / stack / etcが与えられます。任意の標準入力メソッドを介した入力としての符号付き整数

上記のデルタ反転方法に従って、変更されたデータを受け入れ可能な形式でもう一度出力する必要があります。

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であるため、最低のバイト数が優先されます！
• 楽しんで！

勝者がいます。

Tinny 3 BytesでのDennisの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.

Python 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）です。

Mathematica、8バイト

2#-{##}&

引数の数が不定の名前のない関数。これは「簡単な」方法を使用します：リスト全体を無効にし、（元の）最初の要素を2回追加します。

たとえば次のように呼び出され2#-{##}&[1,3,4,2,8]ます。のようなリストを返します{1,-1,-2,0,-6}。

JavaScript（ES6）、21

Thx @Dennis

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

05AB1E、4バイト

¬·s-

オンラインでお試しください！またはテストスイートとして

説明

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

Python、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}}

特にオリジナルではありません。

Perl 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
  )
}

Brain-Flak、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

Haskell、20 19バイト

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

デニスと同じ解決策、あなたのアイデアに感謝します2a - x。

Christian Seversのおかげで1バイト節約できました。

パイク、5 4バイト

h}m-

ここで試してみてください！

PHP、48バイト

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

デニスのテクニックを使用。次のように使用します：

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

デニス以外の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
• } メインスタックの上部を補助スタックの上部に移動します。
• _ スタックの一番上にゼロをプッシュします

オレンジ

このセクションは、現在の番号から2aを減算し、結果を否定し、結果を出力し、次の文字（デリミター）を取得し、EOFの場合は終了し、改行を出力し、次の番号を取得します。

• "いや 北から来る場合、スタックの最上部はゼロになり、プログラムは南に続きます。西から来る場合、スタックの最上部は1になり、プログラムは右に曲がります（南に続く）
• ;スタックの一番上を破棄します。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の場合、スタックの最上部はゼロになり、プログラムはまっすぐに進み@、終了します。最後の文字がデリミターであった場合、スタックの一番上が正になり、プログラムは右に曲がり、東に向かって進みます。\
• \ 改行を出力する
• ? 次の番号を取得
• _1 ジャンクションで右折するために、スタックの一番上に1つを押します

ラビリンス、24バイト

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

入力形式と出力形式は改行で区切られたリストです（ただし、実際には入力形式の方がはるかに柔軟です）。プログラムはエラーで終了します。

オンラインでお試しください！

このバイト数で他の2つのソリューションがあります。これらは基本的には同じですが、多少異なる制御フローを使用します。

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

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

説明

命令ポインター（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.

プログラムのメインループに入り、かなり標準的なトリックを使用して1行のコードをループします。

<...>

スタックをヒットするたびに空になる<ので、そこでゼロが得られることがわかります。次に<、行全体を左に回転させてIPを取得するため、次のようになります。

...><

次に、IPは左に移動する必要があります。ここで、>ラインは元の場所に戻ります（次の反復に備えて）。次に、行は右から左に単純に実行されるため、単一のループ反復は次のようになります。

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

このタイプのループを使用する際の問題は、Labyrinthにはコードをスキップする方法がないため、条件付き実行のフォームを使用できないことです。したがって、EOFに達したときにゼロ除算でプログラムを終了します。各ループ反復の内訳は次のとおりです。

{:   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;}

デニスのテクニックを使用。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は、角かっこで囲まれたリンクが気に入らないと思います。

強引、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トレインであり、2つのネストされた3トレイン（「フォーク」）のように解析されます。 -+(2×⊃)

次のように読みます：-配列全体の否定（）プラス（+）2回（2×）最初の要素（⊃）

ised、11バイト

2*$1_0-$1

呼び出し： ised --l 'file with input.txt' '2*$1_0-$1

（編集：デニスから代数を盗んで修正）

ワンダー、17バイト

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

これを以前に投稿しなかった理由がわかりません。使用法：

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

より読みやすい：

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