Às vezes, quando estou realmente entediado, gosto de pegar a soma de uma matriz de números inteiros não negativos. Eu apenas tomo a soma de matrizes de comprimentos que são potências de dois. Infelizmente, muitas vezes eu cometo erros. Felizmente, acompanho meu trabalho conforme passo a seguir:

Eu adiciono pares de números adjacentes até sobrar apenas um. Por exemplo:

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

Seu trabalho é determinar se cometi um erro em algum lugar. Você pode passar a entrada para sua função ou ler a partir da entrada padrão. A saída pode ser impressa ou retornada.

Entrada: Uma matriz / lista / etc. de números inteiros não negativos e, possivelmente, também o comprimento dessa matriz, se o seu idioma exigir. Essa matriz será todos os números lidos da esquerda para a direita e de cima para baixo. Por exemplo, a matriz acima se tornaria:
[[6, 18, 9, 6, 6, 3, 8, 10], [24, 15, 9, 18], [39, 27], [66]]
ou
[6, 18, 9, 6, 6, 3, 8, 10, 24, 15, 9, 18, 39, 27, 66]se você preferir.

Saída: um único booleano representando se um erro foi cometido ou não. O booleano pode ser representado usando qualquer mapeamento, desde que todas as entradas em que um erro seja cometido retornem / imprimam um resultado idêntico e todas as entradas que não contenham erros retornem / imprimam um resultado idêntico. Isso deve ser óbvio, mas essas duas saídas não podem ser as mesmas.

Alguns exemplos de somatórios corretos:

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

Alguns exemplos de soma incorreta:

5+4
=8

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

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

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

Lembre-se de que eu posso cometer erros e ainda assim obter a resposta certa. Se eu cometer algum erro, isso nunca resultará em um número extra ou um número ausente na matriz final, apenas um número errado.

As brechas padrão são proibidas. A resposta mais curta em cada idioma é um vencedor. A resposta mais antiga vencerá em caso de empate. Eu tenho o direito de decidir qual é a "mesma linguagem", mas direi de antemão que um ponto não pode ser conquistado no Python 2 e no Python 3.

Gelatina , 6 bytes

Ṗ+2/€ẇ

Experimente online!

Como funciona

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

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

Experimente online! Obrigado a Rod pelos casos de teste.

Torna a lista inteira plana como entrada. Agrupa elementos em pares adjacentes usando o truque zip / iter , pega a soma dos pares e verifica se o resultado é igual à segunda metade da lista.

Um método recursivo chegou perto de 55 bytes:

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

Isso usou que os números inteiros de entrada são positivos, que foram alterados nas especificações.

Röda , 40 bytes

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

Experimente online!

É uma função anônima que retorna 0se não houver erros e nada se houver erros.

Explicação:

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

Aqui está uma versão mais curta (35 bytes), mas contra as regras (eu acho):

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

Experimente online!

É uma função anônima que lê valores do fluxo e empurra TRUEou FALSEpara cada linha correta.

Não tenho certeza se isso (vários valores de retorno) é aceito nas regras. Aqui está minha defesa: em Röda, condições ife whileblocos não são valores booleanos, mas fluxos. Um fluxo "verdade" está vazio ou contém apenas TRUEs, e um fluxo "falso" contém um ou mais FALSEs. Dessa maneira, essa função retorna um valor "booleano". E pode ser usado como condição de uma ifdeclaração sem operações de redução, etc.

Python 2 , 69 65 bytes

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

Experimente online!
Retorna:
lista vazia como Falsy
soma total comoTruthy

Mathematica, 36 bytes

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

Função pura, tendo uma lista aninhada como entrada e retornando Trueou False. A função Tr/@#~Partition~2&obtém as somas em pares de uma lista, que são então aplicadas ( /@#) a cada sub-lista da lista de entrada. O primeiro, segundo, ... sublista na lista resultante deve ser igual ao segundo, terceiro, ... sublista na entrada original; Most[...]==Rest@#testes para essa propriedade.

Python 2 , 80 bytes

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

Experimente online!

Não é tão bom quanto a outra resposta python, mas eu queria postá-la de qualquer maneira. Isso só mostra porque eu não sou tão bom no golfe em idiomas regulares .

JavaScript (ES6), 54 bytes

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

Toma uma matriz achatada.

05AB1E , 15 12 bytes

¬svyQy2ôO}\P

Experimente online!

Explicação

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

-14 bytes graças a nimi!

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

Funciona comparando a soma de cada par de elementos com o elemento correspondente na próxima linha abaixo. É provável que alguns bytes possam ser alterados f, mas não consigo descobrir de onde.

Python 3 , 69 68 bytes

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

Eu sei que já existem duas outras respostas em python ... mas essa é em python 3, então é exótico.

Isso funciona em uma entrada achatada.

Saída :

False se não houver erro,

True se houver um erro.

Ruby, 50 bytes

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

Invertendo a matriz, qualquer elemento da primeira metade (posição n) deve ser a soma dos elementos na posição n * 2 en * 2 + 1.

Braquilog , 16 13 bytes

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

Experimente online!

Isso é terrivelmente longo! Deve haver alguma maneira de não aninhar predicados em linha aqui.

O predicado será bem-sucedido (imprimindo true.como um programa) se nenhum erro for cometido e falhar (imprimindo false.como um programa) caso contrário.

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 bytes

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

Experimente online!

Uma função sem nome que pega uma lista de listas (uma por linha de trabalho como se fosse) e retorna True se nenhum erro foi cometido e False caso contrário.

Ele funciona usando a entrada sem a última entrada,, a[:-1]para formar qual deve ser a entrada sem a primeira entrada e verificando se foi a entrada ==a[1:].

Essa formação é alcançada através do mapeamento da função de adição do tipo inteiro int.__add__, sobre os pares de números gerados por duas "fatias", sendo uma fatia todos os outros itens começando no 0º índice, x[::2]e a outra fatia sendo todos os outros itens começando no 1º índice x[1::2],.

Pip , 20 19 bytes

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

Esta é uma função anônima que recebe um argumento, uma lista de listas (por exemplo [[1 2 3 4] [3 7] [10]]). Verifique todos os casos de teste: Experimente online!

Explicação

Em uma função Pip, os dois primeiros argumentos são atribuídos a ae 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)

Por exemplo:

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

usando builtins:

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

funções recursivas retornam trueou false.

repartição da primeira função:

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
}

soluções mais antigas (96 bytes cada) usando loops:

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

repartição da última função:

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

trechos iterativos, 81 bytes

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

assumir matriz predefinida em $a; sai com erro se estiver incorreto.

C, 54 bytes:

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

Teste com

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

Como você vê, f()retorna true para entradas inválidas e false (= 0) para entradas válidas.

Como sempre, a recursão é menos bytes que a iteração, portanto f()é recursiva, mesmo que use dois iteradores como argumentos. Ele funciona comparando repetidamente a soma de dois números inteiros em sum número inteiro em e, ignorando os limites do nível e continuando até que os dois iteradores se encontrem. Também usei um zen booleano juntamente com o fato de que qualquer valor inteiro diferente de zero é considerado verdadeiro em C para reduzir ainda mais o código.

R, 92 77 bytes

Função anônima que recebe uma sequência plana de números como entrada. Retorna TRUEou FALSEconforme apropriado. Usa a mesma abordagem conceitualmente que a resposta python do xnor.

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

Solução anterior, usando a rollapplyfunção do zoopacote, e tendo a entrada como uma lista, por exemplo 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 bytes

Recebe a entrada como uma matriz nivelada. Retorna NaNpara válido ou 0inválido.

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

Teste

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

parâmetro de entrada e URL neste formato, ?0=[1,2,3]&1=[3,3]&2=[6] use esta entrada[[int,int],[int]]

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

Demolir

$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

Japonês, 10 bytes

Recebe a entrada como uma matriz 2-D.

äÏeXò mxÃe

Tente

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