Czasami, gdy naprawdę się nudzę, lubię sumę nieujemnych liczb całkowitych. Biorę tylko sumę tablic długości, które są potęgami dwóch. Niestety często popełniam błędy. Na szczęście śledzę swoją pracę w następujący sposób:

Dodaję pary sąsiednich liczb, aż pozostanie tylko jedna. Na przykład:

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

Twoim zadaniem jest ustalenie, czy gdzieś popełniłem błąd. Możesz albo przekazać dane wejściowe do funkcji, albo odczytać ze standardowego wejścia. Dane wyjściowe można wydrukować lub zwrócić.

Dane wejściowe: tablica / lista / itp. nieujemnych liczb całkowitych, a być może także długość tej tablicy, jeśli twój język tego wymaga. W tej tablicy będą wszystkie liczby odczytywane od lewej do prawej, a następnie od góry do dołu. Na przykład powyższa tablica wygląda następująco:
[[6, 18, 9, 6, 6, 3, 8, 10], [24, 15, 9, 18], [39, 27], [66]]
lub
[6, 18, 9, 6, 6, 3, 8, 10, 24, 15, 9, 18, 39, 27, 66]jeśli wolisz.

Dane wyjściowe: jeden wynik logiczny wskazujący, czy popełniono błąd. Wartość logiczna może być reprezentowana za pomocą dowolnego odwzorowania, pod warunkiem, że wszystkie dane wejściowe, w których popełniono błąd, zwracają / drukują identyczny wynik i wszystkie dane wejściowe, które nie zawierają błędów, zwracają / drukują identyczny wynik. Powinno to być oczywiste, ale te dwa wyjścia nie mogą być takie same.

Niektóre przykłady poprawnych podsumowań:

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

Niektóre przykłady nieprawidłowego podsumowania:

5+4
=8

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

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

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

Pamiętaj, że mogę popełniać błędy i nadal uzyskać właściwą odpowiedź. Jeśli popełniam błąd, nigdy nie spowoduje to otrzymania dodatkowej liczby lub brakującej liczby w końcowej tablicy, tylko złą liczbę.

Standardowe luki są zabronione. Najkrótsza odpowiedź w każdym języku jest zwycięzcą. Starsza odpowiedź wygra w przypadku remisu. Zastrzegam sobie prawo do decydowania, co to jest „ten sam język”, ale powiem z góry, że nie da się zdobyć punktu zarówno w Pythonie 2, jak i Pythonie 3.

Galaretka , 6 bajtów

Ṗ+2/€ẇ

Wypróbuj online!

Jak to działa

Ṗ+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 bajtów

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

Wypróbuj online! Dzięki Rod za przypadki testowe.

Przyjmuje całą listę na płasko jako dane wejściowe. Grupuje elementy w sąsiednie pary za pomocą sztuczki zip / iter , pobiera sumę par i sprawdza, czy wynik jest równy drugiej połowie listy.

Rekurencyjna metoda zbliżył się na 55 bajtów:

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

Użyto tego, że wejściowe liczby całkowite są dodatnie, co od tego czasu zmieniło się w specyfikacji.

Röda , 40 bajtów

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

Wypróbuj online!

Jest to anonimowa funkcja, która zwraca się, 0jeśli nie ma błędów i nic, jeśli są błędy.

Wyjaśnienie:

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

Oto wersja krótsza (35 bajtów), ale niezgodna z regułami (tak myślę):

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

Wypróbuj online!

Jest to anonimowa funkcja, która odczytuje wartości ze strumienia i wypycha TRUElub FALSEdla każdej poprawnej linii.

Nie jestem pewien, czy to (wiele zwracanych wartości) jest akceptowane w regułach. Oto moja obrona: w Rödzie warunki ifi whilebloki nie są wartościami logicznymi, ale strumieniami. Strumień „prawdomówny” jest pusty lub zawiera tylko TRUEs, a strumień „fałsz” zawiera jeden lub więcej FALSEs. W ten sposób funkcja zwraca wartość „boolean”. I może być użyty jako warunek ifinstrukcji bez żadnych operacji redukcji itp.

Python 2 , 69 65 bajtów

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

Wypróbuj online!
Zwraca:
Pusta lista jako Falsy
Suma całkowita jakoTruthy

Mathematica, 36 bajtów

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

Czysta funkcja przyjmuje listę zagnieżdżoną jako dane wejściowe i zwraca Truelub False. Funkcja Tr/@#~Partition~2&pobiera sumy par listy, które są następnie stosowane ( /@#) do każdej listy podrzędnej listy danych wejściowych. Pierwsza, druga ... podlisty na wynikowej liście powinny być równe drugiej, trzeciej, ... podlistom w pierwotnym wejściu; Most[...]==Rest@#testy dla tej właściwości.

Python 2 , 80 bajtów

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

Wypróbuj online!

Nie do końca tak dobra jak druga odpowiedź na python, ale i tak miałem ochotę napisać. To po prostu pokazuje, dlaczego nie jestem tak dobry w golfa w zwykłych językach.

JavaScript (ES6), 54 bajty

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

Przyjmuje spłaszczony układ.

05AB1E , 15 12 bajtów

¬svyQy2ôO}\P

Wypróbuj online!

Wyjaśnienie

¬             # 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 bajtów

-14 bajtów dzięki nim!

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

Działa poprzez porównanie sumy każdej pary elementów z odpowiednim elementem w następnym wierszu w dół. Z niektórych bajtów można prawdopodobnie grać w golfa f, ale nie wiem, gdzie.

Python 3 , 69 68 bajtów

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

Wiem, że są już dwie inne odpowiedzi na python ... ale ta jest w python 3, więc jest egzotyczna.

Działa to na spłaszczonym wejściu.

Wyjście :

False jeśli nie ma pomyłki,

True jeśli jest błąd.

Rubinowy, 50 bajtów

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

Odwracając tablicę, dowolny element pierwszej połowy (pozycja n) musi być sumą elementów w pozycjach n * 2 i n * 2 + 1.

Brachylog , 16 13 bajtów

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

Wypróbuj online!

To jest po prostu strasznie długie! Musi być jakiś sposób, aby nie zagnieżdżać tu predykatów wbudowanych.

Predykat się powiedzie (drukowanie true.jako program), jeśli nie zostaną popełnione żadne błędy, aw false.przeciwnym wypadku (drukowanie jako program).

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 bajty

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

Wypróbuj online!

Nienazwana funkcja, która pobiera listę list (po jednej na linię działania) i zwraca True, jeśli nie popełniono żadnych błędów, lub False w przeciwnym razie.

Działa za pomocą wejścia bez ostatniego wpisu, a[:-1]w celu utworzenia co wejście bez pierwszego wpisu powinna być i sprawdzając, czy to, co było wejściowego ==a[1:].

Formacja ta jest osiągana poprzez odwzorowanie funkcji dodawania typu liczby całkowitej int.__add__na pary liczb otrzymane z dwóch „wycinków”, przy czym jeden wycinek jest co drugi element zaczynający się od 0 indeksu x[::2], a drugi wycinek to każdy inny element zaczynający się od pierwszego indeksu x[1::2].

Pip , 20 19 bajtów

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

Jest to anonimowa funkcja, która pobiera jeden argument, listę list (np [[1 2 3 4] [3 7] [10]].). Sprawdź wszystkie przypadki testowe: wypróbuj online!

Wyjaśnienie

W funkcji Pip dwa pierwsze argumenty są przypisane do ai 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)

Na przykład:

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 bajtów:

za pomocą wbudowanych:

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

funkcje rekurencyjne zwracają truelub false.

podział na pierwszą funkcję:

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
}

starsze rozwiązania (po 96 bajtów) za pomocą pętli:

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

podział na ostatnią funkcję:

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

fragmenty iteracyjne, 81 bajtów

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

przyjmij tablicę predefiniowaną w $a; wychodzi z błędem, jeśli jest niepoprawny.

C, 54 bajty:

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

Nie golfowany:

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

Przetestuj za pomocą

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

Jak widać, f()zwraca true dla nieprawidłowych danych wejściowych i false (= 0) dla prawidłowych danych wejściowych.

Jak zawsze rekurencja ma mniej bajtów niż iteracja, podobnie jak f()rekurencja, mimo że argumentami są dwa iteratory. Działa poprzez wielokrotne porównywanie sumy dwóch liczb całkowitych przy sjednej liczb całkowitych przy e, ignorowanie granic poziomów i kontynuowanie aż do spotkania dwóch iteratorów. Użyłem również logicznego zen wraz z faktem, że każda niezerowa wartość całkowita jest uważana za prawdę w C, aby dodatkowo skrócić kod.

R, 92 77 bajtów

Anonimowa funkcja, która przyjmuje na wejściu płaską sekwencję liczb. Zwraca TRUElub FALSEodpowiednio. Używa tego samego podejścia koncepcyjnego jak odpowiedź python xnor.

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

Poprzednie rozwiązanie, używając rollapplyfunkcji z zoopakietu i biorąc dane wejściowe jako listę, np . 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 bajtów

Pobiera dane wejściowe jako spłaszczoną tablicę. Zwraca NaNza ważne lub 0za nieprawidłowe.

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 bajtów

parametr wejściowy als url w tym formacie ?0=[1,2,3]&1=[3,3]&2=[6] użyj tego wejścia[[int,int],[int]]

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

Awaria

$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 bajtów

Pobiera dane wejściowe jako tablicę 2-D.

äÏeXò mxÃe

Spróbuj

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