Đôi khi, khi tôi thực sự buồn chán, tôi muốn lấy tổng của một loạt các số nguyên không âm. Tôi chỉ lấy tổng các mảng có độ dài là lũy thừa của hai. Thật không may, tôi thường mắc lỗi. May mắn thay tôi theo dõi công việc của tôi khi tôi đi theo cách sau:

Tôi thêm các cặp số liền kề cho đến khi chỉ còn một số. Ví dụ:

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

Công việc của bạn là xác định xem tôi đã phạm sai lầm ở đâu đó chưa. Bạn có thể nhận đầu vào được chuyển đến chức năng của mình hoặc đọc từ tiêu chuẩn. Đầu ra có thể được in hoặc trả lại.

Đầu vào: Một mảng / danh sách / vv. của các số nguyên không âm và có thể cả độ dài của mảng đó nếu ngôn ngữ của bạn yêu cầu. Mảng đó sẽ là tất cả các số đọc từ trái sang phải sau đó từ trên xuống dưới. Ví dụ, mảng trên sẽ trở thành:
[[6, 18, 9, 6, 6, 3, 8, 10], [24, 15, 9, 18], [39, 27], [66]]
hoặc
[6, 18, 9, 6, 6, 3, 8, 10, 24, 15, 9, 18, 39, 27, 66]nếu bạn thích.

Đầu ra: một boolean duy nhất đại diện cho dù có lỗi hay không. Boolean có thể được biểu diễn bằng bất kỳ ánh xạ nào với điều kiện là tất cả các đầu vào có lỗi được trả về / in một kết quả giống hệt nhau và tất cả các đầu vào không có lỗi trả về / in một kết quả giống hệt nhau. Điều này nên đi mà không nói, nhưng hai đầu ra không thể giống nhau.

Một số ví dụ về Tổng kết đúng:

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

Một số ví dụ về Tổng kết không chính xác:

5+4
=8

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

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

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

Hãy nhớ rằng tôi có thể phạm sai lầm và vẫn nhận được câu trả lời đúng. Nếu tôi mắc lỗi, nó sẽ không bao giờ dẫn đến một số thừa hoặc một số bị thiếu trong mảng cuối cùng, chỉ một số sai.

Sơ hở tiêu chuẩn bị cấm. Câu trả lời ngắn nhất trong mỗi ngôn ngữ là một người chiến thắng. Câu trả lời cũ hơn sẽ thắng trong trường hợp hòa. Tôi có quyền quyết định "cùng một ngôn ngữ" là gì, nhưng tôi sẽ nói trước một điểm không thể kiếm được trong cả Python 2 và Python 3.

Thạch , 6 byte

Ṗ+2/€ẇ

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

Ṗ+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:]

Hãy thử trực tuyến! Cảm ơn Rod cho các trường hợp thử nghiệm.

Làm cho toàn bộ danh sách phẳng như đầu vào. Nhóm các phần tử thành các cặp liền kề bằng cách sử dụng thủ thuật zip / iter , lấy tổng của các cặp và kiểm tra xem kết quả có bằng nửa sau của danh sách hay không.

Một phương thức đệ quy đã đóng ở mức 55 byte:

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

Điều này sử dụng rằng các số nguyên đầu vào là dương, từ đó đã thay đổi trong thông số kỹ thuật.

Röda , 40 byte

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

Hãy thử trực tuyến!

Đó là một hàm ẩn danh trả về 0nếu không có lỗi và không có gì nếu có lỗi.

Giải trình:

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

Đây là phiên bản ngắn hơn (35 byte) nhưng trái với quy tắc (tôi nghĩ):

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

Hãy thử trực tuyến!

Đây là một hàm ẩn danh đọc các giá trị từ luồng và đẩy TRUEhoặc FALSEcho từng dòng chính xác.

Tôi không chắc chắn nếu điều này (nhiều giá trị trả về) được chấp nhận trong các quy tắc. Đây là sự bảo vệ của tôi: trong Röda, các điều kiện ifvà whilekhối không phải là giá trị boolean, mà là các luồng. Luồng "trung thực" trống hoặc chỉ chứa TRUEs và luồng "giả" chứa một hoặc nhiều FALSEs. Theo cách này, hàm này trả về giá trị "boolean". Và có thể được sử dụng như một điều kiện của mộtif tuyên bố mà không có bất kỳ hoạt động giảm, v.v.

Python 2 , 69 65 byte

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

Hãy thử trực tuyến!
Trả về:
Danh sách trống dưới dạng Falsy
Tổng cộng dưới dạngTruthy

Toán học, 36 byte

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

Hàm thuần túy lấy một danh sách lồng nhau làm đầu vào và trả về Truehoặc False. Hàm Tr/@#~Partition~2&này tính tổng các cặp của một danh sách, sau đó được áp dụng ( /@#) cho mỗi danh sách con của danh sách đầu vào. Danh sách phụ thứ nhất, thứ hai, ... trong danh sách kết quả được cho là bằng với danh sách phụ thứ hai, thứ ba, ... trong đầu vào ban đầu; Most[...]==Rest@#thử nghiệm cho tài sản này.

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

Hãy thử trực tuyến!

Không hoàn toàn tốt như câu trả lời của con trăn khác, nhưng dù sao tôi cũng cảm thấy muốn đăng nó. Điều này chỉ thể hiện tại sao tôi không giỏi chơi golf bằng các ngôn ngữ thông thường .

JavaScript (ES6), 54 byte

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

Có một mảng phẳng.

05AB1E , 15 12 byte

¬svyQy2ôO}\P

Hãy thử trực tuyến!

Giải trình

¬             # 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 nhờ nimi!

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

Hoạt động bằng cách so sánh tổng từng cặp phần tử với phần tử tương ứng trên dòng tiếp theo xuống. Một số byte có thể được chơi từ đó f, nhưng tôi không thể tìm ra nơi nào.

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)

Tôi biết đã có hai câu trả lời về con trăn khác ... nhưng đây là câu trả lời của con trăn 3, vì vậy nó rất kỳ lạ.

Điều này hoạt động trên một đầu vào phẳng.

Đầu ra :

False nếu không có lỗi,

True nếu có lỗi

Ruby, 50 byte

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

Đảo ngược mảng, bất kỳ phần tử nào của nửa đầu (vị trí n) phải là tổng của các phần tử ở vị trí n * 2 và n * 2 + 1.

Brachylog , 16 13 byte

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

Hãy thử trực tuyến!

Đây chỉ là dài khủng khiếp! Phải có một số cách để không làm tổ vị ngữ nội tuyến ở đây.

Vị ngữ thành công (in true.dưới dạng chương trình) nếu không có lỗi nào xảy ra và thất bại (in false.dưới dạng chương trình) nếu không.

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

Hãy thử trực tuyến!

Một hàm không tên có một danh sách các danh sách (một danh sách trên mỗi dòng hoạt động như vậy) và trả về True nếu không có lỗi nào được thực hiện và Sai khác.

Nó hoạt động bằng cách sử dụng đầu vào mà không có mục nhập cuối cùng a[:-1], để hình thành những gì đầu vào mà không có mục nhập đầu tiên nên và kiểm tra xem đó là những gì đầu vào , ==a[1:].

Sự hình thành này đạt được bằng cách ánh xạ hàm cộng của kiểu số nguyên int.__add__, qua các cặp số được tạo bởi hai "lát", một lát là mọi mục khác bắt đầu từ chỉ số 0, x[::2]lát kia là mọi mục khác bắt đầu từ số 1 chỉ số , x[1::2].

Pip , 20 19 byte

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

Đây là một hàm ẩn danh có một đối số, một danh sách các danh sách (ví dụ [[1 2 3 4] [3 7] [10]]). Xác minh tất cả các trường hợp thử nghiệm: Hãy thử trực tuyến!

Giải trình

Trong hàm Pip, hai đối số đầu tiên được gán cho avà 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)

Ví dụ:

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:

sử dụng nội dung:

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

hàm đệ quy trả về truehoặcfalse .

sự cố cho chức năng đầu tiên:

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
}

các giải pháp cũ hơn (mỗi byte 96) bằng các vòng lặp:

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

sự cố cho chức năng cuối cùng:

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

Đoạn lặp, 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);}

giả sử mảng được xác định trước trong $a; thoát với lỗi nếu nó không chính xác.

C, 54 byte:

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

Ung dung:

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

Kiểm tra với

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

Như bạn thấy đấy, f() trả về true cho các đầu vào không hợp lệ và false (= 0) cho các đầu vào hợp lệ.

Như mọi khi, đệ quy có ít byte hơn lần lặp, vì vậy f()đệ quy, mặc dù phải mất hai lần lặp làm đối số. Nó hoạt động bằng cách liên tục so sánh tổng của hai số nguyên tại smột số nguyên tại e, bỏ qua các ranh giới cấp độ và tiếp tục cho đến khi hai lần lặp gặp nhau. Tôi cũng đã sử dụng một số zen boolean cùng với thực tế là mọi giá trị nguyên khác không được coi là đúng trong C để tiếp tục rút ngắn mã.

R, 92 77 byte

Hàm ẩn danh lấy một dãy số phẳng làm đầu vào. Trả về TRUEhoặc FALSEkhi thích hợp. Sử dụng phương pháp tương tự về mặt khái niệm như câu trả lời python của xnor.

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

Giải pháp trước đó, sử dụng rollapplychức năng từ zoogói và lấy đầu vào làm danh sách, ví dụ 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

Đưa đầu vào như một mảng phẳng. Trả về NaNhợp lệ hoặc 0không hợp lệ.

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

Kiểm tra

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 byte

tham số url als đầu vào trong định dạng ?0=[1,2,3]&1=[3,3]&2=[6] này sử dụng đầu vào này[[int,int],[int]]

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

Phá vỡ

$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

Đưa đầu vào dưới dạng mảng 2 chiều.

äÏeXò mxÃe

Thử nó

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