時々、私が本当に退屈しているとき、非負の整数の配列の合計を取るのが好きです。2のべき乗である長さの配列の合計のみを取ります。残念ながら、私はしばしば間違いを犯します。幸いなことに、私は自分の仕事を次のように追跡しながら追跡しています。

残りの番号が1つになるまで、隣接する番号のペアを追加します。例えば：

 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]あなたが好む場合。

出力：間違いがあったかどうかを表す単一のブール値。ブール値は、ミスが発生したすべての入力が同一の結果を返す/印刷し、ミスを含まないすべての入力が同一の結果を返す/印刷する場合、マッピングを使用して表すことができます。言うまでもなく、これらの2つの出力を同じにすることはできません。

正しい合計の例：

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 trickを使用して要素を隣接するペアにグループ化し、ペアの合計を取得して、結果がリストの後半に等しいかどうかを確認します。

再帰的な方法は、 55バイトに近づきました：

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

これは、入力整数が正であることを使用していましたが、仕様では変更されています。

ローダ、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、または正しい行ごとに呼び出す匿名関数です。

これ（複数の戻り値）がルールで受け入れられるかどうかはわかりません。ここに私の防御がifありwhileます。Rödaでは、条件とブロックはブール値ではなく、ストリームです。「真の」ストリームは空であるかTRUE、s のみを含み、「偽の」ストリームは1つ以上FALSEのsを含みます。このようにして、この関数は「ブール」値を返します。そしての条件として使用することができます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&は、リストのペアごとの合計を取り/@#、入力リストの各サブリストに適用（）します。結果のリストの最初、2番目、...のサブリストは、元の入力の2番目、3番目、...のサブリストと等しいと想定されています。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)

ハスケル、82 79 65バイト

ニミのおかげで-14バイト！

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)

私はすでに他に2つのPythonの答えがあることを知っています...しかし、これはPython 3にあるので、エキゾチックです。

これは、フラット化された入力で機能します。

出力：

False 間違いがなければ、

True 間違いがある場合。

ルビー、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:]

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

リストのリスト（そのままの作業の行ごとに1つ）を受け取り、間違いがなければTrueを返し、そうでない場合はFalseを返す名前のない関数。

これは、最後のエントリのない入力を使用して動作しa[:-1]、最初のエントリのない入力がどうあるべきかを形成し、それが入力であったことを確認します==a[1:]。

この形成は、整数型の加算関数int.__add__を2つの「スライス」によって得られる数のペアにマッピングすることによって実現されx[::2]ます。インデックス、x[1::2]。

ピップ、20 19バイト

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

これは、1つの引数、リストのリスト（例[[1 2 3 4] [3 7] [10]]）を受け取る匿名関数です。すべてのテストケースを確認する：オンラインで試してください！

説明

PIP機能では、最初の2つの引数はに割り当てられている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()、引数として2つの反復子を取りますが、再帰的です。で2つの整数の合計を繰り返し比較することで動作しますsに一つの整数にe、レベルの境界を無視して、2回の反復子が出会うまでに運びます。また、コードをさらに短縮するために、Cではゼロ以外の整数値が真であると見なされるという事実とともに、boolean zenを使用しました。

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バイト

入力を2次元配列として受け取ります。

äÏ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?