A veces, cuando estoy realmente aburrido, me gusta tomar la suma de una serie de enteros no negativos. Solo tomo la suma de matrices de longitudes que son potencias de dos. Lamentablemente, a menudo cometo errores. Afortunadamente, sigo mi trabajo a medida que avanzo de la siguiente manera:

Agrego pares de números adyacentes hasta que solo quede uno. Por ejemplo:

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

Tu trabajo es determinar si he cometido un error en alguna parte. Puede pasar la entrada a su función o leerla desde la entrada estándar. La salida se puede imprimir o devolver.

Entrada: una matriz / lista / etc. de enteros no negativos, y posiblemente también la longitud de esa matriz si su idioma lo requiere. Esa matriz será todos los números leídos de izquierda a derecha y luego de arriba a abajo. Por ejemplo, la matriz anterior se convertiría en:
[[6, 18, 9, 6, 6, 3, 8, 10], [24, 15, 9, 18], [39, 27], [66]]
o
[6, 18, 9, 6, 6, 3, 8, 10, 24, 15, 9, 18, 39, 27, 66]si lo prefiere.

Salida: un booleano único que representa si se cometió o no un error. El booleano se puede representar usando cualquier mapeo siempre que todas las entradas donde se comete un error devuelvan / impriman un resultado idéntico y todas las entradas que no contengan errores devuelvan / impriman un resultado idéntico. Esto debería ser evidente, pero esas dos salidas no pueden ser iguales.

Algunos ejemplos de suma correctas:

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

Algunos ejemplos de suma incorrecta:

5+4
=8

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

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

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

Tenga en cuenta que puedo cometer errores y aún así obtener la respuesta correcta. Si cometo un error, nunca dará como resultado un número adicional o un número faltante en la matriz final, solo un número incorrecto.

Las lagunas estándar están prohibidas. La respuesta más corta en cada idioma es un ganador. La respuesta anterior ganará en caso de empate. Me reservo el derecho de decidir cuál es el "mismo idioma", pero diré por adelantado que no se puede ganar un punto tanto en Python 2 como en Python 3.

Jalea , 6 bytes

Ṗ+2/€ẇ

Pruébalo en línea!

Cómo 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:]

Pruébalo en línea! Gracias a Rod por los casos de prueba.

Toma toda la lista plana como entrada. Agrupa elementos en pares adyacentes utilizando el truco zip / iter , toma la suma de los pares y comprueba si el resultado es igual a la segunda mitad de la lista.

Un método recursivo se acercó a los 55 bytes:

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

Esto usó que los enteros de entrada son positivos, lo que desde entonces ha cambiado en la especificación.

Röda , 40 bytes

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

Pruébalo en línea!

Es una función anónima que regresa 0si no hay errores y nada si hay errores.

Explicación:

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

Aquí hay una versión más corta (35 bytes) pero en contra de las reglas (creo):

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

Pruébalo en línea!

Es una función anónima que lee valores de la secuencia y empuja TRUEo FALSEpara cada línea correcta.

No estoy seguro de si esto (múltiples valores de retorno) se acepta en las reglas. Aquí está mi defensa: en Röda, las condiciones ify los whilebloques no son valores booleanos, sino flujos. Un flujo "verdadero" está vacío o contiene solo TRUEs, y un flujo "falso" contiene uno o más FALSEs. De esta manera, esta función devuelve un valor "booleano". Y se puede usar como condición de una ifdeclaración sin ninguna operación de reducción, etc.

Python 2 , 69 65 bytes

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

Pruébalo en línea!
Devoluciones:
Lista vacía como Falsy
suma total comoTruthy

Mathematica, 36 bytes

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

Función pura que toma una lista anidada como entrada y regresa Trueo False. La función Tr/@#~Partition~2&toma las sumas por pares de una lista, que luego se aplica ( /@#) a cada sublista de la lista de entrada. Se supone que la primera, segunda, ... sublistas en la lista resultante son iguales a la segunda, tercera, ... sublistas en la entrada original; Most[...]==Rest@#pruebas para esta propiedad.

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

Pruébalo en línea!

No es tan bueno como la otra respuesta de Python, pero tuve ganas de publicarlo de todos modos. Esto solo muestra por qué no soy tan bueno jugando al golf en idiomas regulares .

JavaScript (ES6), 54 bytes

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

Toma una matriz aplanada.

05AB1E , 15 12 bytes

¬svyQy2ôO}\P

Pruébalo en línea!

Explicación

¬             # 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 gracias 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 la suma de cada par de elementos con el elemento correspondiente en la siguiente línea hacia abajo. Probablemente se puedan jugar algunos bytes f, pero no puedo entender dónde.

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)

Sé que ya hay otras dos respuestas de Python ... pero esta está en Python 3, por lo que es exótica.

Esto funciona en una entrada aplanada.

Salida :

False si no hay error

True Si hay un error.

Ruby, 50 bytes.

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

Al invertir la matriz, cualquier elemento de la primera mitad (posición n) debe ser la suma de los elementos en la posición n * 2 yn * 2 + 1.

Brachylog , 16 13 bytes

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

Pruébalo en línea!

¡Esto es terriblemente largo! Tiene que haber alguna forma de no anidar predicados en línea aquí.

El predicado tiene éxito (imprimiendo true.como un programa) si no se cometieron errores y falla (imprimiendo false.como un programa) de lo contrario.

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

Pruébalo en línea!

Una función sin nombre que toma una lista de listas (una por línea de trabajo, por así decirlo), y devuelve True si no se cometieron errores y False de lo contrario.

Funciona mediante el uso de la entrada sin la última entrada, a[:-1]para formar lo que debe ser la entrada sin la primera entrada y comprobar que es lo que era de entrada, ==a[1:].

Esta formación se logra mediante el mapeo de la función de suma del tipo entero int.__add__, sobre los pares de números producidos por dos "sectores", un segmento es cada otro elemento que comienza en el índice 0, x[::2]y el otro segmento es cada otro elemento que comienza en el primer índice, x[1::2].

Pip , 20 19 bytes

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

Esta es una función anónima que toma un argumento, una lista de listas (por ejemplo [[1 2 3 4] [3 7] [10]]). Verifique todos los casos de prueba: ¡ Pruébelo en línea!

Explicación

En una función Pip, los dos primeros argumentos se asignan a ay 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 ejemplo:

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

funciones recursivas retorno trueo false.

Desglose para la primera funció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
}

soluciones anteriores (96 bytes cada una) usando bucles:

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

Desglose para la última función:

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

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

asumir matriz predefinida en $a; sale con error si es incorrecto.

C, 54 bytes:

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

Sin golf:

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

Prueba con

#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 puede ver, f()devuelve verdadero para entradas no válidas y falso (= 0) para las válidas.

Como siempre, la recursión es menos bytes que la iteración, por lo que f()es recursiva, a pesar de que toma dos iteradores como argumentos. Funciona comparando repetidamente la suma de dos enteros en sun entero en e, ignorando los límites de nivel y continuando hasta que los dos iteradores se encuentran. También he usado algo de zen booleano junto con el hecho de que cualquier valor entero distinto de cero se considera verdadero en C para acortar aún más el código.

R, 92 77 bytes

Función anónima que toma una secuencia plana de números como entrada. Devoluciones TRUEo FALSEsegún corresponda. Utiliza el mismo enfoque conceptual que la respuesta python de xnor.

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

Solución anterior, usando la rollapplyfunción del zoopaquete y tomando la entrada como una lista, por ejemplo 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

Toma la entrada como una matriz aplanada. Devoluciones NaNválidas o 0inválidas.

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

Prueba

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

el parámetro input als url en este formato ?0=[1,2,3]&1=[3,3]&2=[6] usa 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;

Descompostura

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

Toma la entrada como una matriz 2-D.

äÏeXò mxÃe

Intentalo

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