Manchmal, wenn mir wirklich langweilig ist, nehme ich gerne die Summe einer Reihe von nicht negativen ganzen Zahlen. Ich nehme nur die Summe der Längenfelder, die Zweierpotenzen sind. Leider mache ich oft Fehler. Glücklicherweise verfolge ich meine Arbeit auf folgende Weise:

Ich füge Paare benachbarter Zahlen hinzu, bis nur noch eine übrig ist. Beispielsweise:

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

Sie müssen feststellen, ob ich irgendwo einen Fehler gemacht habe. Sie können entweder Eingaben an Ihre Funktion übergeben oder Standardeingaben einlesen. Die Ausgabe kann gedruckt oder zurückgegeben werden.

Eingabe: Ein Array / Liste / etc. von nicht-negativen ganzen Zahlen, und möglicherweise auch die Länge dieses Arrays, wenn Ihre Sprache es erfordert. In diesem Array werden alle Zahlen von links nach rechts und dann von oben nach unten gelesen. Zum Beispiel würde das Array oben lauten:
[[6, 18, 9, 6, 6, 3, 8, 10], [24, 15, 9, 18], [39, 27], [66]]
oder
[6, 18, 9, 6, 6, 3, 8, 10, 24, 15, 9, 18, 39, 27, 66]wenn Sie es vorziehen.

Ausgabe: Ein einzelner Boolescher Wert, der angibt, ob ein Fehler gemacht wurde oder nicht. Der Boolesche Wert kann unter Verwendung einer beliebigen Zuordnung dargestellt werden, vorausgesetzt, dass alle Eingaben, bei denen ein Fehler gemacht wurde, ein identisches Ergebnis zurückgeben / ausgeben und alle Eingaben, die keine Fehler enthalten, ein identisches Ergebnis zurückgeben / ausgeben. Dies sollte selbstverständlich sein, aber diese beiden Ausgänge können nicht gleich sein.

Einige Beispiele für korrekte Summierungen:

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

Einige Beispiele für eine falsche Summierung:

5+4
=8

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

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

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

Denken Sie daran, dass ich Fehler machen und trotzdem die richtige Antwort bekommen kann. Wenn ich einen Fehler mache, führt dies nie zu einer zusätzlichen Nummer oder einer fehlenden Nummer im endgültigen Array, sondern nur zu einer falschen Nummer.

Standardlücken sind verboten. Die kürzeste Antwort in jeder Sprache ist ein Gewinner. Die ältere Antwort gewinnt im Falle eines Gleichstands. Ich behalte mir das Recht zu entscheiden, was die "gleiche Sprache" ist, aber ich sage im Voraus, dass ein Punkt in Python 2 und Python 3 nicht verdient werden kann.

Gelee , 6 Bytes

Ṗ+2/€ẇ

Probieren Sie es online!

Wie es funktioniert

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

Probieren Sie es online! Vielen Dank an Rod für die Testfälle.

Nimmt die gesamte Liste als Eingabe. Gruppiert Elemente in benachbarte Paare mit zip / iter-Trick berechnet die Summe der Paare und prüft, ob das Ergebnis der zweiten Hälfte der Liste entspricht.

Eine rekursive Methode kam 55 Bytes nahe:

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

Dies verwendete, dass Eingabe-Ganzzahlen positiv sind, was sich seitdem in der Spezifikation geändert hat.

Röda , 40 Bytes

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

Probieren Sie es online!

Es ist eine anonyme Funktion, die zurückgibt, 0wenn keine Fehler vorliegen, und nichts, wenn Fehler vorliegen.

Erläuterung:

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

Hier ist eine Version, die kürzer ist (35 Bytes), aber gegen die Regeln verstößt (glaube ich):

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

Probieren Sie es online!

Es ist eine anonyme Funktion, die Werte aus dem Stream liest und TRUEoder FALSEfür jede richtige Zeile pusht.

Ich bin nicht sicher, ob dies (mehrere Rückgabewerte) in den Regeln akzeptiert wird. Hier ist meine Verteidigung: In Röda sind Bedingungen ifund whileBlöcke keine booleschen Werte, sondern Streams. Ein "wahrer" Stream ist entweder leer oder enthält nur TRUEs, und ein "falscher" Stream enthält ein oder mehrere FALSEs. Auf diese Weise gibt diese Funktion einen "booleschen" Wert zurück. Und kann als Bedingung für eine ifAnweisung ohne Reduktionsoperationen usw. verwendet werden.

Python 2 , 69 65 Bytes

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

Probieren Sie es online!
Rückgabe:
Leere Liste als Falsy
Gesamtsumme alsTruthy

Mathematica, 36 Bytes

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

Reine Funktion, die eine verschachtelte Liste als Eingabe verwendet und Trueoder zurückgibt False. Die Funktion berechnet Tr/@#~Partition~2&die paarweisen Summen einer Liste, die dann /@#auf jede Unterliste der Eingabeliste angewendet wird ( ). Die ersten, zweiten, ... Unterlisten in der resultierenden Liste sollen den zweiten, dritten, ... Unterlisten in der ursprünglichen Eingabe entsprechen; Most[...]==Rest@#Tests für diese Eigenschaft.

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

Probieren Sie es online!

Nicht ganz so gut wie die andere Python-Antwort, aber ich wollte sie trotzdem posten. Dies zeigt nur, warum ich nicht so gut in regulären Sprachen Golf spielen kann.

JavaScript (ES6), 54 Byte

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

Nimmt ein abgeflachtes Array auf.

05AB1E , 15 12 Bytes

¬svyQy2ôO}\P

Probieren Sie es online!

Erläuterung

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

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

Vergleichen Sie die Summe jedes Elementpaars mit dem entsprechenden Element in der nächsten Zeile. Einige Bytes können wahrscheinlich abgegolft werden f, aber ich kann nicht herausfinden, wo.

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)

Ich weiß, dass es bereits zwei andere Python-Antworten gibt ... aber diese ist in Python 3, es ist also exotisch.

Dies funktioniert bei einer abgeflachten Eingabe.

Ausgabe :

False Wenn es keinen Fehler gibt,

True wenn es einen Fehler gibt.

Ruby, 50 Bytes

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

Um das Array umzukehren, muss jedes Element der ersten Hälfte (Position n) die Summe der Elemente in Position n * 2 und n * 2 + 1 sein.

Brachylog , 16 bis 13 Bytes

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

Probieren Sie es online!

Das ist einfach furchtbar lang! Es muss eine Möglichkeit geben, Inline-Prädikate hier nicht zu verschachteln.

Das Prädikat ist erfolgreich (Drucken true.als Programm), wenn keine Fehler gemacht wurden, und schlägt fehl (Drucken false.als Programm), wenn keine Fehler gemacht wurden .

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

Probieren Sie es online!

Eine unbenannte Funktion, die eine Liste von Listen annimmt (eine pro Arbeitszeile) und True zurückgibt, wenn keine Fehler gemacht wurden, andernfalls False.

Es funktioniert, indem die Eingabe ohne den letzten Eintrag verwendet wird a[:-1], um zu bilden, was die Eingabe ohne den ersten Eintrag sein soll, und zu überprüfen, ob dies die Eingabe ist ==a[1:].

Diese Bildung wird erreicht, indem die Additionsfunktion des Integer-Typs int.__add__auf die Zahlenpaare abgebildet wird , die aus zwei "Schichten" resultieren, wobei eine Schicht jedes zweite Element ist, das mit dem 0. Index beginnt, x[::2]und die andere Schicht jedes zweite Element ist, das mit dem 1. beginnt Index x[1::2].

Pip , 20 bis 19 Bytes

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

Dies ist eine anonyme Funktion, die ein Argument akzeptiert, eine Liste von Listen (z [[1 2 3 4] [3 7] [10]]. B. ). Überprüfen Sie alle Testfälle: Probieren Sie es online!

Erläuterung

In einer PIP - Funktion werden die ersten beiden Argumente zugewiesen aund 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)

Beispielsweise:

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 bis 95 Bytes:

mit eingebauten:

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

rekursive Funktionen kehren zurück true oder zurück false.

Nervenzusammenbruch für die erste Funktion:

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
}

ältere Lösungen (jeweils 96 Byte) mit Schleifen:

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

Nervenzusammenbruch für letzte Funktion:

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

iterative Ausschnitte, 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);}

Nehmen Sie an, dass das Array in vordefiniert ist $a. Beendet mit Fehler, wenn es falsch ist.

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

Testen Sie mit

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

Wie du siehst, f() bei ungültigen Eingaben true und bei gültigen Eingaben false (= 0) zurückgegeben.

Wie immer ist die Rekursion weniger Bytes als die Iteration f() ist auch rekursiv, obwohl zwei Iteratoren als Argumente verwendet werden. Dies funktioniert, indem wiederholt die Summe zweier Ganzzahlen smit einer Ganzzahl verglichen wird, die Ebenengrenzen eignoriert werden und so lange fortgefahren wird, bis sich die beiden Iteratoren treffen. Ich habe auch einige boolesche Zen-Werte zusammen mit der Tatsache verwendet, dass ein ganzzahliger Wert ungleich Null in C als wahr angesehen wird, um den Code weiter zu verkürzen.

R, 92 77 Bytes

Anonyme Funktion, die eine flache Folge von Zahlen als Eingabe verwendet. Rückgabe TRUEoderFALSE entsprechend. Verwendet konzeptionell den gleichen Ansatz wie die Python-Antwort von xnor.

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

Vorherige Lösung, die die rollapplyFunktion aus dem zooPaket verwendet und Eingaben als Liste aufnimmt, z 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

Übernimmt die Eingabe als abgeflachtes Array. Rückgabe NaNfür gültig oder 0ungültig.

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

Prüfung

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

Die Eingabe als URL-Parameter in diesem Format ?0=[1,2,3]&1=[3,3]&2=[6] verwendet diese Eingabe[[int,int],[int]]

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

Nervenzusammenbruch

$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

Übernimmt die Eingabe als 2D-Array.

äÏeXò mxÃe

Versuch es

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