Іноді, коли мені дуже нудно, я люблю брати суму масиву невід’ємних цілих чисел. Я беру лише суму масивів довжин, які є потужністю дві. На жаль, я часто роблю помилки. На щастя, я стежу за своєю роботою, коли йду далі таким чином:

Я додаю пари сусідніх чисел, поки не залишиться лише один. Наприклад:

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

Спробуйте в Інтернеті! Дякую Роду за тестові справи.

Збирає весь список рівним як вхідний. Групує елементи в сусідні пари за допомогою трюку zip / iter , бере суму пар і перевіряє, чи результат дорівнює другій половині списку.

Рекурсивний метод був близький по 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для кожного правильного рядка.

Я не впевнений, чи прийнято це (кілька повернених значень) у правилах. Ось мій захист: у 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

Математика, 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))

Спробуйте в Інтернеті!

Не зовсім так добре, як інші відповіді пітона, але я все одно відчував, як розміщувати його. Це просто показує, чому я не так добре граю в гольф звичайними мовами.

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 байт завдяки німі!

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

Брахілог , 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-го індексу x[::2], а другий - кожен інший елемент, починаючи з 1-го. індекс 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, ігнорування меж рівня та продовження, поки два ітератори не зустрінуться. Я також використав деякий булевий дзен разом з тим, що будь-яке ненульове ціле число вважається істинним у С, щоб додатково скоротити код.

R, 92 77 байт

Анонімна функція, яка приймає як вхід плоску послідовність чисел. Повертається TRUEабо FALSEвідповідно. Концептуально використовується той же підхід, що і відповідь 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))

Попереднє рішення, використовуючи 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 байти

?0=[1,2,3]&1=[3,3]&2=[6] цей вхід використовує параметр URL-адреси als у цьому форматі[[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?