阵列的反增量

给定一个带符号的32位整数数组，您的任务是使用其反增量重新编译它。例如清单

1  3  4  2  8

包含增量：

  2  1 -2  6

然后取反，得到：

 -2 -1  2 -6

并重新编译，产生：

1 -1 -2  0 -6

作为最终结果。

输入输出

您将得到一个列表/数组/表/元组/堆栈/等。通过任何标准输入法输入的带符号整数的数量。

您必须按照上述增量反转方法，以任何可接受的形式再次输出修改后的数据。

您将收到N个输入，0 < N < 10其中每个数字都在该范围内-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个。
• 输出的第一个数字必须始终是输入的第一个数字，如果不是这种情况，则您的方法不正确。
• 仅接受标准输入输出
• 适用标准漏洞
• 这是代码高尔夫球，因此最低的字节数为准！
• 玩得开心！

我们有一个赢家。

丹尼斯（Dennis）的《3个字节小巧的果冻答案》（Jelly Answer）夺回了金牌，因为我印象中无法击败它。

令我有些失望的是，我没有看到基于原始规格的答案，但是，稍后我可能会对此给予赏金。

果冻，7 3 个字节

ḤḢ_

在线尝试！

背景

的增量（A，B，C，d）是b -一个，Ç - B，和d - Ç。通过减法g 累计减少（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 -一个，Ç - B，和d - Ç。通过减法g 累计减少（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#-{##}&[1,3,4,2,8]; 返回类似的列表{1,-1,-2,0,-6}。

JavaScript（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

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

自动矢量化和默认打印可助您一臂之力！

Ruby，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
  )
}

脑筋急转弯，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

与Dennis相同的解决方案，谢谢您的想法 2a - x。

感谢Christian Severs，节省了一个字节。

Pyke，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 将两个推到栈顶
• *流行y，流行x，推x*y
• } 将主烟囱的顶部移至辅助烟囱的顶部。
• _ 将零推到栈顶

橙子

此部分从当前数字中减去2a，取反结果，输出结果，获取下一个字符（分号），如果EOF退出，输出换行符，获取下一个数字。

• "没事 如果来自北方，则栈顶将为零，程序将继续向南。如果来自西方，则堆栈的顶部将为一，并且程序将向右转（继续向南）
• ;丢弃堆栈顶部。由于零或一仅用于控制流，我们需要丢弃这些
• { 将辅助烟囱（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 将一个推到堆栈的顶部，以便在路口向右转

迷宫，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.

现在，我们使用相当标准的技巧进入程序的主循环，以单行代码循环：

<...>

请注意，只要我们点击，堆栈就会为空，<因此我们知道在那里会得到零。在<随后旋转整条生产线离开，带走了该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个字节

作为未命名的lambda，修改其输入：

[](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不喜欢它带有括号的链接。

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

（编辑：通过从丹尼斯窃取代数来纠正）

不可思议，17个字节

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

不知道为什么我没有更早发布这个。用法：

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

更具可读性：

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