Parfois, quand je m'ennuie vraiment, j'aime prendre la somme d'un tableau d'entiers non négatifs. Je ne prends que la somme des tableaux de longueurs qui sont des puissances de deux. Malheureusement, je fais souvent des erreurs. Heureusement, je garde la trace de mon travail au fur et à mesure de la manière suivante:

J'ajoute des paires de nombres adjacents jusqu'à ce qu'il n'en reste plus qu'un. Par exemple:

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

Votre travail consiste à déterminer si j'ai fait une erreur quelque part. Vous pouvez soit faire passer l'entrée à votre fonction ou lire à partir de l'entrée standard. La sortie peut être imprimée ou retournée.

Entrée: Un tableau / liste / etc. d'entiers non négatifs, et éventuellement aussi la longueur de ce tableau si votre langue l'exige. Ce tableau sera tous les nombres lus de gauche à droite puis de haut en bas. Par exemple, le tableau ci-dessus deviendrait:
[[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]si vous préférez.

Sortie: un seul booléen indiquant si une erreur a été commise ou non. Le booléen peut être représenté en utilisant n'importe quel mappage à condition que toutes les entrées où une erreur est commise retournent / impriment un résultat identique et toutes les entrées qui ne contiennent aucune erreur retournent / impriment un résultat identique. Cela va sans dire, mais ces deux sorties ne peuvent pas être identiques.

Quelques exemples de sommations correctes:

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

Quelques exemples de sommation incorrecte:

5+4
=8

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

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

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

Gardez à l'esprit que je peux faire des erreurs tout en obtenant la bonne réponse. Si je fais une erreur, cela n'entraînera jamais un nombre supplémentaire ou un nombre manquant dans le tableau final, seulement un mauvais numéro.

Les failles standard sont interdites. La réponse la plus courte dans chaque langue est gagnante. La réponse la plus ancienne l'emportera en cas d'égalité. Je conserve le droit de décider ce qu'est le "même langage", mais je dirai tout de suite qu'un point ne peut pas être gagné à la fois en Python 2 et en Python 3.

Gelée , 6 octets

Ṗ+2/€ẇ

Essayez-le en ligne!

Comment ça marche

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

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

Essayez-le en ligne! Merci à Rod pour les cas de test.

Prend toute la liste à plat en entrée. Regroupe les éléments en paires adjacentes à l'aide de l' astuce zip / iter , prend la somme des paires et vérifie si le résultat est égal à la seconde moitié de la liste.

Une méthode récursive s'est approchée de 55 octets:

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

Cela a utilisé que les entiers d'entrée sont positifs, ce qui a depuis changé dans la spécification.

Röda , 40 octets

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

Essayez-le en ligne!

C'est une fonction anonyme qui revient 0s'il n'y a pas d'erreurs et rien s'il y a des erreurs.

Explication:

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

Voici une version plus courte (35 octets) mais contraire aux règles (je pense):

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

Essayez-le en ligne!

C'est une fonction anonyme qui lit les valeurs du flux et pousse TRUEou FALSEpour chaque ligne correcte.

Je ne sais pas si cela (plusieurs valeurs de retour) est accepté dans les règles. Voici ma défense: dans Röda, les conditions de ifet les whileblocs ne sont pas des valeurs booléennes, mais des flux. Un flux "véridique" est soit vide, soit ne contient que des TRUEs, et un flux "falsifié" contient un ou plusieurs FALSEs. De cette façon, cette fonction renvoie une valeur "booléenne". Et peut être utilisé comme condition d'une ifinstruction sans aucune opération de réduction, etc.

Python 2 , 69 65 octets

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

Essayez-le en ligne!
Renvoie:
Liste vide en tant que Falsy
somme totale en tant queTruthy

Mathematica, 36 octets

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

Fonction pure prenant une liste imbriquée en entrée et retournant Trueou False. La fonction Tr/@#~Partition~2&prend les sommes par paire d'une liste, qui est ensuite appliquée ( /@#) à chaque sous-liste de la liste d'entrée. Les première, deuxième, ... sous-listes de la liste résultante sont censées égaler les deuxième, troisième, ... sous-listes de l'entrée d'origine; Most[...]==Rest@#teste cette propriété.

Python 2 , 80 octets

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

Essayez-le en ligne!

Pas aussi bon que l'autre réponse python, mais j'avais envie de le poster quand même. Cela montre simplement pourquoi je ne suis pas aussi bon au golf dans les langues régulières .

JavaScript (ES6), 54 octets

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

Prend un tableau aplati.

05AB1E , 15 12 octets

¬svyQy2ôO}\P

Essayez-le en ligne!

Explication

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

-14 octets grâce à nimi!

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

Fonctionne en comparant la somme de chaque paire d'éléments à l'élément correspondant sur la ligne suivante. Certains octets peuvent probablement être joués au golf f, mais je ne sais pas où.

Python 3 , 69 68 octets

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

Je sais qu'il y a déjà deux autres réponses en python ... mais celle-ci est en python 3, donc c'est exotique.

Cela fonctionne sur une entrée aplatie.

Sortie :

False s'il n'y a pas d'erreur,

True s'il y a une erreur.

Rubis, 50 octets

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

En inversant le tableau, tout élément de la première moitié (position n) doit être la somme des éléments en position n * 2 et n * 2 + 1.

Brachylog , 16 13 octets

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

Essayez-le en ligne!

C'est terriblement long! Il doit y avoir un moyen de ne pas imbriquer les prédicats en ligne ici.

Le prédicat réussit (impression en true.tant que programme) si aucune erreur n'a été commise et échoue (impression en false.tant que programme) dans le cas contraire.

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 octets

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

Essayez-le en ligne!

Une fonction sans nom qui prend une liste de listes (une par ligne de travail pour ainsi dire) et renvoie True si aucune erreur n'a été commise et False sinon.

Cela fonctionne en utilisant l'entrée sans la dernière entrée, a[:-1]pour former ce que l'entrée sans la première entrée devrait être et en vérifiant ce qui a été entré,==a[1:] .

Cette formation est obtenue en mappant la fonction d'addition du type entier int.__add__, sur les paires de nombres fournies par deux "tranches", une tranche étant tous les autres éléments commençant au 0e index x[::2], l'autre tranche étant tous les autres éléments commençant au 1er index, x[1::2].

Pip , 20 19 octets

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

Il s'agit d'une fonction anonyme qui prend un argument, une liste de listes (par exemple [[1 2 3 4] [3 7] [10]]). Vérifiez tous les cas de test: essayez-le en ligne!

Explication

Dans une fonction Pip, les deux premiers arguments sont affectés à aet 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)

Par exemple:

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

en utilisant des 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);}

les fonctions récursives renvoient trueou false.

ventilation pour la première fonction:

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
}

anciennes solutions (96 octets chacune) utilisant des boucles:

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

ventilation pour la dernière fonction:

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

extraits itératifs, 81 octets

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

supposer tableau prédéfini dans $a; se ferme avec erreur s'il est incorrect.

C, 54 octets:

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

Testez avec

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

Comme vous le voyez, f()renvoie true pour les entrées non valides et false (= 0) pour les entrées valides.

Comme toujours, la récursivité est moins d'octets que l'itération, elle f()est donc récursive, même si elle prend deux itérateurs comme arguments. Il fonctionne en comparant à plusieurs reprises la somme de deux entiers à sà un entier en e, ignorant les limites de niveau et continuant jusqu'à ce que les deux itérateurs se rencontrent. J'ai également utilisé du zen booléen avec le fait que toute valeur entière non nulle est considérée comme vraie en C pour raccourcir davantage le code.

R, 92 77 octets

Fonction anonyme qui prend en entrée une séquence de nombres plats. Retourne TRUEou FALSEselon le cas. Utilise la même approche conceptuellement que la réponse 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))

Solution précédente, en utilisant la rollapplyfonction du zoopackage et en prenant l'entrée comme une liste, par exemple 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 octets

Prend l'entrée comme un tableau aplati. Renvoie NaNpour valide ou 0pour invalide.

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

Tester

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 octets

entrée als paramètre url dans ce format ?0=[1,2,3]&1=[3,3]&2=[6] utiliser cette entrée[[int,int],[int]]

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

Panne

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

Prend l'entrée comme un tableau 2D.

äÏeXò mxÃe

L'essayer

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