A volte, quando sono davvero annoiato, mi piace prendere la somma di un array di numeri interi non negativi. Prendo solo la somma di matrici di lunghezze che sono poteri di due. Purtroppo faccio spesso errori. Fortunatamente tengo traccia del mio lavoro mentre procedo nel modo seguente:

Aggiungo coppie di numeri adiacenti fino a quando ne rimane solo uno. Per esempio:

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

Il tuo compito è determinare se ho fatto un errore da qualche parte. È possibile ottenere l'input passato alla funzione o leggere dallo standard in. L'output può essere stampato o restituito.

Input: un array / elenco / ecc. di numeri interi non negativi, e possibilmente anche la lunghezza di quell'array se la tua lingua lo richiede. Quell'array sarà composto da tutti i numeri letti da sinistra a destra, quindi dall'alto verso il basso. Ad esempio l'array sopra diventerebbe:
[[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]se preferisci.

Output: un singolo booleano che rappresenta se è stato commesso o meno un errore. Il valore booleano può essere rappresentato utilizzando qualsiasi mappatura a condizione che tutti gli input in cui viene commesso un errore restituiscano / stampino un risultato identico e tutti gli input che non contengono errori restituiscano / stampino un risultato identico. Questo dovrebbe essere ovvio, ma quei due output non possono essere gli stessi.

Alcuni esempi di riassunti corretti:

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

Alcuni esempi di sommatoria errata:

5+4
=8

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

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

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

Tieni presente che posso fare errori e ottenere comunque la risposta giusta. Se commetto un errore, non comporterà mai un numero aggiuntivo o un numero mancante nell'array finale, solo un numero errato.

Sono vietate le scappatoie standard. La risposta più breve in ogni lingua è un vincitore. La risposta più vecchia vincerà in caso di pareggio. Mi riservo il diritto di decidere quale sia la "stessa lingua", ma dirò in anticipo che un punto non può essere guadagnato in Python 2 e Python 3.

Gelatina , 6 byte

Ṗ+2/€ẇ

Provalo online!

Come funziona

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

Provalo online! Grazie a Rod per i casi di test.

Rende l'intero elenco piatto come input. Raggruppa gli elementi in coppie adiacenti usando il trucco zip / iter , prende la somma delle coppie e controlla se il risultato è uguale alla seconda metà dell'elenco.

Un metodo ricorsivo si avvicinò a 55 byte:

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

Questo ha usato i numeri interi di input positivi, che da allora sono cambiati nelle specifiche.

Röda , 40 byte

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

Provalo online!

È una funzione anonima che ritorna 0se non ci sono errori e niente se ci sono errori.

Spiegazione:

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

Ecco una versione più corta (35 byte) ma contro le regole (penso):

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

Provalo online!

È una funzione anonima che legge i valori dallo stream e invia TRUEo FALSEper ogni riga corretta.

Non sono sicuro che questo (più valori di ritorno) sia accettato nelle regole. Ecco la mia difesa: a Röda, le condizioni ife i whileblocchi non sono valori booleani, ma flussi. Un flusso "truey" è vuoto o contiene solo TRUEs e un flusso "falsy" contiene uno o più FALSEs. In questo modo, questa funzione restituisce un valore "booleano". E può essere utilizzato come condizione di ifun'istruzione senza riduzioni, ecc.

Python 2 , 69 65 byte

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

Provalo online!
Restituisce:
Elenco vuoto come Falsy
somma totale comeTruthy

Mathematica, 36 byte

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

Funzione pura che prende un elenco nidificato come input e che restituisce Trueo False. La funzione Tr/@#~Partition~2&accetta le somme a coppie di un elenco, che viene quindi applicato ( /@#) a ciascun elenco secondario dell'elenco di input. Il primo, secondo, ... elenco secondario dell'elenco risultante dovrebbe essere uguale al secondo, terzo, elenco secondario nell'input originale; Most[...]==Rest@#test per questa proprietà.

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

Provalo online!

Non abbastanza buono come l'altra risposta di Python, ma mi è venuta voglia di pubblicarlo comunque. Questo dimostra solo perché non sono bravo a giocare a golf in lingue normali .

JavaScript (ES6), 54 byte

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

Prende un array appiattito.

05AB1E , 15 12 byte

¬svyQy2ôO}\P

Provalo online!

Spiegazione

¬             # 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 grazie a nimi!

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

Funziona confrontando la somma di ciascuna coppia di elementi con l'elemento corrispondente nella riga successiva in basso. Alcuni byte possono probabilmente essere golfati f, ma non riesco a capire dove.

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)

So che ci sono già altre due risposte di Python ... ma questa è in Python 3, quindi è esotica.

Funziona su un input appiattito.

Uscita :

False se non ci sono errori,

True se c'è un errore.

Rubino, 50 byte

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

Invertire la matrice, qualsiasi elemento del primo tempo (posizione n) deve essere la somma degli elementi nella posizione n * 2 e n * 2 + 1.

Brachylog , 16 13 byte

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

Provalo online!

Questo è terribilmente lungo! Deve esserci un modo per non annidare predicati in linea qui.

Il predicato ha true.esito positivo (stampa come programma) se non vengono commessi errori e non riesce (stampa false.come programma) in caso 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 byte

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

Provalo online!

Una funzione senza nome che accetta un elenco di elenchi (uno per riga di funzionamento per così dire) e restituisce True se non sono stati commessi errori e False in caso contrario.

Funziona utilizzando l'ingresso, senza l'ultima voce, a[:-1]per formare quello che l'ingresso, senza la prima voce dovrebbe essere e il controllo che è quello che era entrata, ==a[1:].

Questa formazione è ottenuta mappando la funzione di addizione del tipo intero int.__add__, sulle coppie di numeri prodotte da due "sezioni", una fetta è ogni altro elemento a partire dal 0 ° indice x[::2], l'altra fetta è ogni altro oggetto a partire dal 1 ° indice x[1::2].

Pip , 20 19 byte

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

Questa è una funzione anonima che accetta un argomento, un elenco di elenchi (ad es [[1 2 3 4] [3 7] [10]].). Verifica tutti i casi di test: provalo online!

Spiegazione

In una funzione Pip, i primi due argomenti sono assegnati 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)

Per esempio:

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:

usando i builtin:

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

ritorno di funzioni ricorsive trueo false.

guasto per la prima funzione:

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
}

soluzioni precedenti (96 byte ciascuna) utilizzando i loop:

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

ripartizione per ultima funzione:

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

frammenti iterativi, 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);}

assume array predefinito in $a; esce con errore se non è corretto.

C, 54 byte:

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

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

Come vedi, f()restituisce true per input non validi e false (= 0) per input validi.

Come sempre, la ricorsione è meno byte dell'iterazione, quindi f()è ricorsiva, anche se prende due iteratori come argomenti. Funziona confrontando ripetutamente la somma di due numeri interi scon un numero intero in e, ignorando i limiti di livello e proseguendo fino a quando i due iteratori si incontrano. Ho anche usato un po 'di zen booleano insieme al fatto che qualsiasi valore intero diverso da zero è considerato vero in C per abbreviare ulteriormente il codice.

R, 92 77 byte

Funzione anonima che accetta come input una sequenza piatta di numeri. Resi TRUEo FALSEcome appropriato. Utilizza concettualmente lo stesso approccio della risposta python di xnor.

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

Soluzione precedente, utilizzando la rollapplyfunzione dal zoopacchetto e prendendo input come elenco, ad esempio 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

Accetta l'input come un array appiattito. Restituisce NaNper valido o 0per non valido.

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

Test

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

input als url parameter in this format ?0=[1,2,3]&1=[3,3]&2=[6] use this input [[int,int],[int]]

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

Breakdown

$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

Takes input as a 2-D array.

äÏeXò mxÃe

Try it

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