有时候，当我真的很无聊时，我喜欢取一个非负整数数组的总和。我只取长度为2的幂的数组的总和。不幸的是我经常犯错误。幸运的是，我通过以下方式跟踪自己的工作：

我添加成对的相邻数字，直到只剩下一个。例如：

 6 + 18 + 9 + 6 + 6 + 3 + 8 + 10
=  24   +   15  +   9   +   18
=       39      +       27
=               66

您的工作是确定我是否在某个地方犯了错误。您既可以将输入传递给函数，也可以从标准输入中读取。可以打印或返回输出。

输入：数组/列表/等。非负整数，如果您的语言需要，还可以包含该数组的长度。该数组将是从左到右然后从上到下读取的所有数字。例如，上面的数组将变为：
[[6, 18, 9, 6, 6, 3, 8, 10], [24, 15, 9, 18], [39, 27], [66]]
或者，
[6, 18, 9, 6, 6, 3, 8, 10, 24, 15, 9, 18, 39, 27, 66]如果您愿意。

输出：单个布尔值，表示是否犯了错误。可以使用任何映射来表示布尔值，条件是发生错误的所有输入都返回/打印相同的结果，而没有错误的所有输入都返回/打印相同的结果。这不言而喻，但是这两个输出不能相同。

正确求和的一些示例：

6

5+6
=11

  3 + 2 + 4 + 5
=   5   +   9
=       14

[0, 1, 2, 3, 1, 5, 6]

[[1, 2, 4, 8], [3, 12], [15]]

不正确求和的一些示例：

5+4
=8

4 + 4 + 4 + 4
= 9   +   7
=     16

[[1, 2, 3, 4], [7, 3], [10]]

[3, 4, 5, 6, 7, 8, 9]

请记住，我可能会犯错误，但仍会得到正确的答案。如果我确实犯了一个错误，它将永远不会导致最终数组中出现多余的数字或缺少数字，而只会导致错误的数字。

禁止出现标准漏洞。每种语言中最短的答案是获胜者。如果是平局，则较早的答案将获胜。我保留决定“相同语言”是什么的权利，但我要说的是，Python 2和Python 3都无法赚到一点。

果冻，6个字节

Ṗ+2/€ẇ

在线尝试！

怎么运行的

Ṗ+2/€ẇ  Main link. Argument: A (2D array)

Ṗ       Pop; yield A without its last element. Let's call the result B.
  2/    Pairwise reduce...
    €     each array in B...
 +          by addition.
     ẇ  Window exists; test if the result appears in A as a contiguous subarray.

Python 2，51个字节

lambda l:map(sum,zip(*[iter(l)]*2))==l[len(l)/2+1:]

在线尝试！感谢Rod提供了测试用例。

将整个列表放平作为输入。使用zip / iter技巧将元素分组为相邻的对，获取对的总和，并检查结果是否等于列表的后半部分。

一个递归方法在55个字节差点：

f=lambda l:len(l)<2or l[0]+l[1]==l[len(l)/2+1]*f(l[2:])

这使用输入整数为正，此后在规范中进行了更改。

Röda，40个字节

{[0]if{|x|[[x()|[_+_]]=y]if tryPeek y}_}

在线尝试！

这是一个匿名函数，0如果没有错误，则返回，如果有错误，则不返回。

说明：

{[0]if{|x|[[x()|[_+_]]=y]if tryPeek y}_}
{                                      } /* Anonymous function */
      {|x|                           }_  /* Loop over lists in the stream */
                         if tryPeek y    /* If there are lists left after this */
            x()                          /* Push values in list x to the stream */
               |[_+_]                    /* Sum every pair of numbers in x */
           [         ]                   /* Create a list of sums */
                      =y                 /* If the list equals to the next list */
          [             ]                /* Push the result */
    if                                   /* If all results are TRUE */
 [0]                                     /* Return 0 */
                                         /* Otherwise return nothing */

这是一个较短的版本（35字节），但是违反了规则（我认为）：

{{|x|[[x()|[_+_]]=y]if tryPeek y}_}

在线尝试！

这是一个匿名函数，它从流中读取值并推送TRUE或FALSE为每条正确的线输入。

我不确定规则中是否接受此值（多个返回值）。这是我的辩护：在Röda中，if和的条件while不是布尔值，而是流。“真实”流为空或仅包含TRUEs，而“虚假”流包含一个或多个FALSEs。这样，此函数将返回“布尔”值。并且可以用作if语句的条件，而无需任何归约运算等。

Python 2中，69 65个字节

lambda x:reduce(lambda a,b:(b==map(sum,zip(a[::2],a[1::2])))*b,x)

在线尝试！
返回：
空列表作为Falsy
总和为Truthy

Mathematica，36个字节

Most[Tr/@#~Partition~2&/@#]==Rest@#&

将嵌套列表作为输入并返回True或的纯函数False。该函数Tr/@#~Partition~2&采用列表的成对和，然后将（/@#）应用于输入列表的每个子列表。结果列表中的第一，第二，...子列表应该等于原始输入中的第二，第三，...子列表；Most[...]==Rest@#测试此属性。

Python 2，80个字节

lambda l:all(l[i+1]==map(sum,zip(l[i][::2],l[i][1::2]))for i in range(len(l)-1))

在线尝试！

不如其他python回答好，但我还是想发布它。这只是说明为什么我不擅长使用普通语言打高尔夫球。

JavaScript（ES6），54个字节

a=>!a.slice(-a.length/2).some((n,i)=>a[i+=i]+a[i+1]-n)

采取扁平化的数组。

05AB1E，15 12字节

¬svyQy2ôO}\P

在线尝试！

说明

¬             # get the first element from input without popping
 sv      }    # for each element y in input
   yQ         # compare y to the top of the stack 
              # leaves 1 on the stack if equal and otherwise 0
     y2ô      # split y in pieces of 2
        O     # sum each pair in the list
          \   # discard the top of the stack (the left over final element of the list)
           P  # product of stack (all the 1's and/or 0's from the comparisons)

Haskell，82 79 65字节

-14个字节感谢nimi！

p(x:y:z)=x+y:p z
f x=and.zipWith(==)(drop(length x`div`2+1)x)$p x

通过将每对元素的总和与下一行的对应元素进行比较来进行工作。可能可以从中读取一些字节f，但是我不知道在哪里。

Python 3中，69 68个字节

lambda v:any(x+v[i-1]-v[(len(v)+i)//2]for i,x in enumerate(v)if i%2)

我知道已经有另外两个python答案了...但是这个在python 3中，所以很奇怪。

这适用于拼合输入。

输出：

False 如果没有错误，

True 如果有错误。

Ruby，50个字节

->x{a=b=0;b&&=x[a/2]==x[a]+x[a-1]while x[-a-=2];b}

反转数组，前半部分（位置n）的任何元素都必须是位置n * 2和n * 2 + 1中元素的总和。

Brachylog，16 13字节

s₂ᵘ{{ġ₂+ᵐ}ᵈ}ᵐ

在线尝试！

这真是可怕的长！必须有某种方法不将内联谓词嵌套在这里。

true.如果没有出错，则谓词成功（作为程序打印false.），否则失败（作为程序打印）。

s₂ᵘ              Every length 2 substring of the input
   {       }ᵐ    for every element satisfies the following:
    {ġ₂          the pairs of elements of the input
       +ᵐ        when each pair is summed is the output
         }ᵈ      where the input is the first item and the output is the second.

Python 2，64个字节

lambda a:[map(int.__add__,x[::2],x[1::2])for x in a[:-1]]==a[1:]

在线尝试！

一个未命名的函数，使用一个列表列表（每行工作一个），如果没有犯错误，则返回True，否则返回False。

它通过使用没有最后一个输入a[:-1]的输入来形成没有第一个输入的输入并检查输入是什么而起作用==a[1:]。

这种形成是通过将整数类型的加法函数映射到int.__add__由两个“切片”产生的数字对上来实现的，一个切片是从第0个索引开始的每隔一个项目，另一个切片是从第1个索引x[::2]开始的每隔一个项目索引x[1::2]。

点，20 19字节

$*{{b=$+*Ya<>2}MPa}

这是一个匿名函数，带有一个参数，即列表列表（例如[[1 2 3 4] [3 7] [10]]）。验证所有测试用例：在线尝试！

说明

在Pip函数中，前两个参数分配给a和b。

  {               }  Anonymous function:
   {          }MPa    To each pair of sublists from a, map this helper function:
          a<>2         Group the 1st member of the pair into 2-item sublists
         Y             Yank that value (no-op used to override precedence order)
      $+*              Map (*) the fold ($) on addition (+) operator
    b=                 If the 2nd member of the pair is = to the result, 1; else 0
$*                   Modify the outside function by folding its return value on *
                     (makes a list containing all 1's into 1 and any 0's into 0)

例如：

a
[[1 2 3 4] [7 3] [10]]

{...}MP
a:[1 2 3 4] b:[7 3]
a:[7 3]     b:[10]

a<>2
[[1 2] [3 4]]
[[7 3]]

$+*
[3 7]
[10]

b=
0
1

Final result of {...}MPa
[0 1]

$*
0

PHP， 96 95字节：

使用内置函数：

function f($a){return!$a[1]||array_pop($a)==array_map(array_sum,array_chunk(end($a),2))&f($a);}
// or
function f($a){return!$a[1]||array_map(array_sum,array_chunk(array_shift($a),2))==$a[0]&f($a);}

递归函数返回 true或false。

分解第一项功能的：

function f($a){
    return!$a[1]||      // true if array has no two rows ... or
    array_pop($a)==     // remove last row, true if equal to
    array_map(array_sum,    // 3. sum up every chunk
        array_chunk(        // 2. split to chunks of 2
            end($a)         // 1. new last row
        ,2))
    &f($a);             // and recursion returns true
}

较旧的解决方案使用循环的（每个96字节）：

function f($a){foreach($a[0]as$k=>$v)$b[$k/2]+=$v;return$b==$a[1]&&!$a[2]|f(array_slice($a,1));}
//or
function f($a,$y=0){foreach($a[$y]as$k=>$v)$b[$k/2]+=$v;return$b==$a[++$y]&&!$a[$y+1]|f($a,$y);}

分解的最后一个函数：

function f($a,$y=0){
    foreach($a[$y]as$k=>$v)$b[$k/2]+=$v;    // build $b with correct sums from current row
    return$b==$a[++$y]                      // true if $b equals next row
    &&!$a[$y+1]                             // and (finished
        |f($a,$y);                          //      or recursion returns true)
}

迭代片段，81字节

for(;$a[1];)if(array_pop($a)!=array_map(array_sum,array_chunk(end($a),2)))die(1);
for(;$a[1];)if(array_map(array_sum,array_chunk(array_shift($a),2))!=$a[0])die(1);
for(;$a[++$y];$b=[]){foreach($a[$y-1]as$k=>$v)$b[$k/2]+=$v;if($a[$y]!=$b)die(1);}

假设在中预定义了数组$a；如果不正确则退出并返回错误。

C，54个字节：

f(int*s,int*e){return e-s>1?*s+s[1]-*e||f(s+2,e+1):0;}

取消高尔夫：

int f(int*s,int*e) {
    if(e-s>1) {
        return *s+s[1] != *e || f(s+2,e+1);
    } else {
        return 0;
    }
}

测试

#include <assert.h>
int main() {
    int input1[15] = {6, 18, 9, 6, 6, 3, 8, 10, 24, 15, 9, 18, 39, 27, 66};
    assert(!f(input1, input1+8));

    int input2[7] = {3, 4, 5, 6, 7, 8, 9};
    assert(f(input2, input2+4));
}

正如你看到的， f()对于无效输入返回true，对于有效输入返回false（= 0）。

与往常一样，递归比迭代少字节f()，即使递归使用两个迭代器作为参数，递归也是如此。它通过重复比较处的两个整数的总和与处s的一个整数的总和e，而忽略了层边界，并一直进行到两个迭代器满足为止。我还使用了一些布尔禅，以及在C中将任何非零整数值都视为true的事实，以进一步缩短代码。

R，92 77字节

匿名函数，它以平坦的数字序列作为输入。返回TRUE或FALSE视情况而定。在概念上使用与xnor的python答案相同的方法。

function(x,l=sum(1|x)/2)all(rowSums(cbind(x[1:l*2-1],x[1:l*2]))==tail(x,l-1))

先前的解决方案，使用包中的rollapply函数zoo，并将输入作为列表，例如list(c(6, 18, 9, 6, 6, 3, 8, 10), c(24, 15, 9, 18), c(39, 27), c(66))：

function(l,T=1){for(i in 2:length(l))T=T&all(zoo::rollapply(l[[i-1]],2,sum,by=2)==l[[i]]);T}

JavaScript（ES6），46 44字节

将输入作为展平数组。返回NaN有效还是0无效。

f=([a,b,...c])=>a+b==c[c.length>>1]?f(c):b-b

测试

f=([a,b,...c])=>a+b==c[c.length>>1]?f(c):b-b

console.log(f([6, 18, 9, 6, 6, 3, 8, 10, 24, 15, 9, 18, 39, 27, 66])) // NaN
console.log(f([0, 1, 2, 3, 1, 5, 6]))                                 // NaN
console.log(f([1, 2, 4, 8, 3, 12, 15]))                               // NaN
console.log(f([1, 2, 3, 4, 7, 3, 10]))                                // 0
console.log(f([3, 4, 5, 6, 7, 8, 9]))                                 // 0

PHP，102字节

以这种格式输入als url参数?0=[1,2,3]&1=[3,3]&2=[6] 使用此输入[[int,int],[int]]

<?$r=[$_GET[0]];for(;count(end($r))>1;)$r[]=array_map(array_sum,array_chunk(end($r),2));echo$r==$_GET;

分解

$r=[$_GET[0]]; # Set the first item of the input in the result array 
for(;count(end($r))>1;) # till the last item in the result array has only one int
$r[]=array_map(array_sum,array_chunk(end($r),2));# add the next item to the result array
echo$r==$_GET; # compare the input array with the result array

Japt，10个字节

将输入作为二维数组。

äÏeXò mxÃe

试试吧

äÏeXò mxÃe     :Implicit input of 2-D array
ä              :Reduce each consecutive pair of sub-arrays
 Ï             :By passing them through the following function as X & Y, respectively
  e            :  Test Y for equality with
   Xò          :    Split X on every 2nd element
      m        :    Map
       x       :      Reduce by addition
        Ã      :End function
         e     :All true?