Иногда, когда мне очень скучно, мне нравится брать сумму целого ряда неотрицательных целых чисел. Я беру только сумму массивов длин, которые являются степенями двух. К сожалению, я часто делаю ошибки. К счастью, я слежу за своей работой следующим образом:

Я добавляю пары соседних номеров, пока не останется только один. Например:

 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

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 байт благодаря Ними!

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 если есть ошибка.

Рубин, 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;}

Ungolfed:

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 для дальнейшего сокращения кода.

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 байта

входной параметр 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?