Kadang-kadang, ketika saya benar-benar bosan, saya suka mengambil jumlah array bilangan non-negatif. Saya hanya mengambil jumlah array panjang yang merupakan kekuatan dua. Sayangnya saya sering melakukan kesalahan. Untungnya saya melacak pekerjaan saya karena saya mengikuti cara berikut:

Saya menambahkan pasangan angka yang berdekatan sampai hanya ada satu yang tersisa. Sebagai contoh:

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

Tugas Anda adalah menentukan apakah saya telah membuat kesalahan di suatu tempat. Anda bisa mendapatkan input yang diteruskan ke fungsi Anda atau membaca dari standar masuk. Output dapat dicetak atau dikembalikan.

Input: Array / daftar / dll. bilangan bulat non-negatif, dan mungkin juga panjang array jika bahasa Anda membutuhkannya. Array itu adalah semua angka yang dibaca dari kiri ke kanan lalu atas ke bawah. Misalnya array di atas akan menjadi:
[[6, 18, 9, 6, 6, 3, 8, 10], [24, 15, 9, 18], [39, 27], [66]]
atau
[6, 18, 9, 6, 6, 3, 8, 10, 24, 15, 9, 18, 39, 27, 66]jika Anda suka.

Keluaran: boolean tunggal yang menunjukkan apakah ada kesalahan atau tidak. Boolean dapat direpresentasikan menggunakan pemetaan apa pun asalkan semua input di mana kesalahan dibuat mengembalikan / mencetak hasil yang identik dan semua input yang tidak mengandung kesalahan mengembalikan / mencetak hasil yang identik. Ini harus berjalan tanpa mengatakan, tetapi dua output tidak bisa sama.

Beberapa Contoh Penjumlahan yang Benar:

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]]

Beberapa Contoh Penjumlahan Tidak Benar:

5+4
=8

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

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

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

Ingatlah bahwa saya dapat membuat kesalahan dan masih mendapatkan jawaban yang benar. Jika saya melakukan kesalahan, itu tidak akan menghasilkan angka tambahan atau nomor hilang dalam array terakhir, hanya nomor yang salah.

Celah standar dilarang. Jawaban terpendek dalam setiap bahasa adalah pemenang. Jawaban yang lebih lama akan menang dalam kasus seri. Saya memiliki hak untuk memutuskan apa "bahasa yang sama" itu, tetapi saya akan mengatakan di muka bahwa suatu titik tidak dapat diperoleh dalam Python 2, dan Python 3.

Jelly , 6 byte

Ṗ+2/€ẇ

Cobalah online!

Bagaimana itu bekerja

Ṗ+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 byte

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

Cobalah online! Terima kasih kepada Rod untuk kasus uji.

Membuat seluruh daftar datar sebagai masukan. Grup elemen menjadi pasangan yang berdekatan menggunakan trik zip / iter , mengambil jumlah pasangan, dan memeriksa apakah hasilnya sama dengan bagian kedua dari daftar.

Sebuah metode rekursif datang dekat pada 55 byte:

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

Ini digunakan bahwa bilangan bulat input positif, yang sejak itu berubah dalam spesifikasi.

Röda , 40 byte

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

Cobalah online!

Ini adalah fungsi anonim yang mengembalikan 0jika tidak ada kesalahan dan tidak ada jika ada kesalahan.

Penjelasan:

{[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 */

Berikut adalah versi yang lebih pendek (35 byte) tetapi bertentangan dengan aturan (saya pikir):

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

Cobalah online!

Ini adalah fungsi anonim yang membaca nilai dari aliran dan mendorong TRUEatau FALSEuntuk setiap baris yang benar.

Saya tidak yakin apakah ini (nilai pengembalian berganda) diterima dalam aturan. Inilah pertahanan saya: di Reda, kondisi ifdan whileblok bukan nilai boolean, tetapi stream. Aliran "benar" kosong atau hanya berisi TRUEs, dan aliran "falsy" berisi satu atau lebih FALSEs. Dengan cara ini, fungsi ini mengembalikan nilai "boolean". Dan dapat digunakan sebagai kondisi ifpernyataan tanpa mengurangi operasi, dll.

Python 2 , 69 65 byte

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

Cobalah online!
Pengembalian:
Daftar Kosong sebagai Falsy
Jumlah total sebagaiTruthy

Mathematica, 36 byte

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

Fungsi murni mengambil daftar bersarang sebagai input dan kembali Trueatau False. Fungsi ini Tr/@#~Partition~2&mengambil jumlah berpasangan dari suatu daftar, yang kemudian diterapkan ( /@#) ke setiap sublist dari daftar input. Sublist pertama, kedua, ... dalam daftar yang dihasilkan seharusnya sama dengan sublist kedua, ketiga, ... di input asli; Most[...]==Rest@#tes untuk properti ini.

Python 2 , 80 byte

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

Cobalah online!

Tidak sebagus jawaban python lainnya, tapi saya merasa ingin mempostingnya. Ini hanya untuk menunjukkan mengapa saya tidak pandai golf dalam bahasa biasa .

JavaScript (ES6), 54 byte

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

Mengambil array yang diratakan.

05AB1E , 15 12 byte

¬svyQy2ôO}\P

Cobalah online!

Penjelasan

¬             # 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 byte

-14 byte terima kasih kepada nimi!

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

Bekerja dengan membandingkan jumlah setiap pasangan elemen dengan elemen yang sesuai pada baris berikutnya ke bawah. Beberapa byte mungkin bisa dipasangkan dari golf f, tapi saya tidak tahu di mana.

Python 3 , 69 68 byte

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

Saya tahu sudah ada dua jawaban python lain ... tapi yang ini dalam python 3, jadi ini eksotis.

Ini bekerja pada input yang diratakan.

Keluaran :

False jika tidak ada kesalahan,

True jika ada kesalahan.

Ruby, 50 byte

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

Membalikkan array, elemen apa pun dari babak pertama (posisi n) harus merupakan jumlah elemen di posisi n * 2 dan n * 2 + 1.

Brachylog , 16 13 byte

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

Cobalah online!

Ini sangat lama! Harus ada cara untuk tidak menempatkan predikat inline di sini.

Predikat berhasil (mencetak true.sebagai program) jika tidak ada kesalahan dibuat dan gagal (mencetak false.sebagai program) sebaliknya.

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 byte

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

Cobalah online!

Fungsi yang tidak disebutkan namanya yang mengambil daftar daftar (satu per baris bekerja seolah-olah), dan mengembalikan Benar jika tidak ada kesalahan dibuat dan Salah sebaliknya.

Ini bekerja dengan menggunakan input tanpa entri terakhir a[:-1],, untuk membentuk apa input tanpa entri pertama seharusnya dan memeriksa apa itu input ==a[1:],.

Formasi ini dicapai dengan memetakan fungsi penambahan tipe integer int.__add__,, pada pasangan angka yang dihasilkan oleh dua "irisan", satu irisan menjadi setiap item lainnya mulai dari indeks 0,, x[::2]irisan lainnya menjadi setiap item lainnya mulai dari tanggal 1 indeks x[1::2],.

Pip , 20 19 byte

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

Ini adalah fungsi anonim yang mengambil satu argumen, daftar daftar (misalnya [[1 2 3 4] [3 7] [10]]). Verifikasi semua kasus uji: Coba online!

Penjelasan

Dalam fungsi Pip, dua argumen pertama ditugaskan ke adan 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)

Sebagai contoh:

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 byte:

menggunakan builtin:

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

fungsi rekursif kembali trueatau false.

kerusakan untuk fungsi pertama:

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
}

solusi yang lebih lama (masing-masing 96 byte) menggunakan loop:

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

kerusakan untuk fungsi terakhir:

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

cuplikan berulang, 81 byte

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

menganggap array sudah ditentukan sebelumnya dalam $a; keluar dengan kesalahan jika salah.

C, 54 byte:

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

Tidak Disatukan:

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

Tes dengan

#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));
}

Seperti yang Anda lihat, f()mengembalikan true untuk input yang tidak valid dan false (= 0) untuk input yang valid.

Seperti biasa, rekursi lebih kecil byte daripada iterasi, begitu f()juga rekursif, meskipun dibutuhkan dua iterator sebagai argumen. Ia bekerja dengan berulang kali membandingkan jumlah dari dua bilangan bulat pada ssatu bilangan bulat di e, mengabaikan batas level, dan melanjutkan sampai dua iterator bertemu. Saya juga telah menggunakan beberapa boolean zen bersama dengan fakta bahwa nilai integer non-nol dianggap benar dalam C untuk lebih memperpendek kode.

R, 92 77 byte

Fungsi anonim yang mengambil urutan angka datar sebagai input. Pengembalian TRUEatau yang FALSEsesuai. Menggunakan pendekatan yang sama secara konseptual dengan jawaban python xnor.

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

Solusi sebelumnya, menggunakan rollapplyfungsi dari zoopaket, dan mengambil input sebagai daftar, misalnya 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 byte

Mengambil input sebagai array yang diratakan. Pengembalian NaNuntuk yang valid atau 0tidak valid.

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

Uji

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 Bytes

masukan juga parameter url dalam format ?0=[1,2,3]&1=[3,3]&2=[6] ini menggunakan input ini[[int,int],[int]]

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

Kerusakan

$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 byte

Mengambil input sebagai array 2-D.

äÏeXò mxÃe

Cobalah

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