Schreiben Sie ein Programm oder eine Funktion, die bei n ≥ 1 die Anzahl der Lösungen auf ± 1 ± 2 ± 3 ± ... ± n = 0 zurückgibt.

Für n = 6 gibt es keine Lösungen, die Antwort ist 0. Für n = 4 gibt es zwei Lösungen, die Antwort ist 2 (die beiden Lösungen sind 1 - 2 - 3 + 4 = -1 + 2 + 3 - 4 = 0).

Dies ist die OEIS-Sequenz A063865 . Einige Beispiele für Ein- / Ausgänge sind:

n       a(n)
1       0
2       0
3       2
4       2
5       0
6       0
7       8
8       14
9       0
10      0
11      70
12      124
13      0
14      0
15      722
16      1314

Kürzester Code in Bytes gewinnt.

JavaScript (ES6), 35 Byte

1 Byte dank @tsh gespeichert

f=(n,s)=>n--?f(n,n-~s)+f(n,n+~s):!s

Probieren Sie es online!

Wolfram Language (Mathematica) , 33 Byte

Count[{1,-1}~Tuples~#.Range@#,0]&

Zählt die n-Tupel von 1 und -1, deren Skalarprodukt mit Range[n]0 ist.

Probieren Sie es online!

Haskell , 42 Bytes

f n=sum[1|0<-sum<$>mapM(\x->[x,-x])[1..n]]

Probieren Sie es online!

Dies ist 2 1 Byte kürzer als jede rekursive Funktion, die ich schreiben könnte.

05AB1E , 10 Bytes

X®‚sã€ƶO_O

Probieren Sie es online!

Erläuterung

X®‚          # push [1,-1]
   sã        # cartesian product with input
     €ƶ      # multiply each element in each list with its 1-based index
       O     # sum each list
        _    # logical negation of each sum
         O   # sum

C (gcc), 45 62 52 50 Bytes

f(n,r){n=n?f(n-1,r+n)+f(n-1,r-n):!r;}F(n){f(n,0);}

Port von Kevin Cruijssens Java 8- Antwort .

Probieren Sie es hier online aus .

Beachten Sie, dass der Code aufgrund der in den Kommentaren vorgeschlagenen Verbesserungen undefiniertes Verhalten erzeugt, sodass er beim Kompilieren mit Clang nicht mehr funktioniert.

Vielen Dank an Etene für das Golfen mit 3 Bytes. Vielen Dank an Kevin Cruijssen für das Golfen mit 10 weiteren Bytes. Vielen Dank an Christoph für die weiteren 2 Bytes.

Ungolfed-Version:

f(n, r) { // recursive function - return type and parameter type are omitted, they default to int
    n = // instead of returning, we set n - dirty trick
        n ? // if n is not 0, recurse
        f(n-1,r+n) // +n
       +f(n-1,r-n) // -n
        !r; // else if r != 0 return 0 else return 1
}
F(n) { // function to start the recursion; again implicitly int(int)
    n = f(n, 0); // call the recursive function; this time we simply don't return
}

05AB1E , 9 8 Bytes

Danke an Emigna für das Speichern eines Bytes!

Code:

LæO·sLO¢

Verwendet die 05AB1E- Codierung. Probieren Sie es online!

Erläuterung

L           # Create the list [1, 2, .., input]
 æ          # Compute the powerset of this list
  O         # Sum each list
   ·        # Double each element
    sLO     # Compute the sum of [1, 2, .., input]
       ¢    # Count the number of occurrences

MATL , 14 13 Bytes

[la]Z^G:!Y*~s

Vielen Dank an @ Giuseppe für das Speichern von 1 Byte!

Probieren Sie es online! Oder überprüfen Sie alle Testfälle .

Erläuterung

Betrachten Sie n = 3als Beispiel. Der Stapel wird verkehrt herum angezeigt, dh der neueste Stapel wird unten angezeigt.

[la]   % Push array [1 -1]
       % STACK: [1 -1]
Z^     % Cartesian power with inplicit input n
       % STACK: [ 1  1  1
                  1  1 -1
                  1 -1  1
                  1 -1 -1
                 -1  1  1
                 -1  1 -1
                 -1 -1  1
                 -1 -1 -1]
G:     % Push n, range: gives [1 2 ... n]
       % STACK: [ 1  1  1
                  1  1 -1
                  1 -1  1
                  1 -1 -1
                 -1  1  1
                 -1  1 -1
                 -1 -1  1
                 -1 -1 -1],
                 [1  2  3]
!      % Transpose
       % STACK: [ 1  1  1
                  1  1 -1
                  1 -1  1
                  1 -1 -1
                 -1  1  1
                 -1  1 -1
                 -1 -1  1
                 -1 -1 -1],
                 [1
                  2
                  3]
Y*     % Matrix multiplication
       % STACK: [6
                 0
                 2
                -4
                 4
                -2
                 0
                -6]
~      % Logical negation
       % STACK: [0
                 1
                 0
                 0
                 0
                 0
                 1
                 0]
s      % Sum of vector. Implicit display
       % STACK: 2

Gelee , 8 Bytes

ŒPS€ċÆṁ$

Probieren Sie es online!

Wie es funktioniert

ŒPS€ċÆṁ$  Main link. Argument: n

ŒP        Take the powerset of [1, ..., n].
  S€      Take the sum of each subset.
       $  Combine the two links to the left into a monadic chain.
     Æṁ       Compute the median of the sums, i.e, (1 + ... + n)/2.
    ċ         Count the occurrences of the median.

Python 2, 74 Bytes

def f(n):l=k=1;exec"l+=l<<n*k;k+=1;"*n;return(l>>n*n*-~n/4)%2**n*(~-n%4>1)

Mehr Spaß beim Einreichen, direkte Berechnung der generierenden Funktionen.

Oktave (mit Kommunikationspaket), 39 Byte

@(n)sum((2*de2bi(0:2^n-1)-1)*(1:n)'==0)

Probieren Sie es online!

Erläuterung:

Nehmen Sie einen Bereich von 0 ... n ^ 2-1 und wandeln Sie ihn in Binär um. Dies ergibt eine Matrix mit allen Kombinationen von 0 und 1 . Mit 2 multiplizieren und 1 abziehen , um eine Matrix mit allen Kombinationen von -1 und +1 zu erhalten .

Nehmen Sie das Skalarprodukt mit einer Auswahl 1 ... n , um alle Kombinationen von ± 1 ± 2 ... ± n zu erhalten . Zählen Sie, wie viele Null sind.

Grundsätzlich das Gleiche, die gleiche Anzahl von Bytes:

@(n)nnz(~((2*de2bi(0:2^n-1)-1)*(1:n)'))

APL (Dyalog) , 31 22 Bytes

9 Bytes gespart dank @ H.PWiz

1⊥0=⊂∘⍳+.ר∘,3-2×∘⍳⍴∘2

Probieren Sie es online!

Python 2 und 3, 50 Bytes

Rekursiver Ansatz wie die meisten Antworten:

f=lambda n,r=0:f(n-1,r+n)+f(n-1,r-n)if n else r==0

Probieren Sie es online aus

Der doppelte rekursive Aufruf nimmt zu viele Bytes in Anspruch ... Es gibt wahrscheinlich eine Möglichkeit, ihn zu vereinfachen.

Java 8, 72 71 70 Bytes

n->f(0,n)int f(int r,int n){return n>0?f(r+n,--n)+f(r+~n,n):r==0?1:0;}

Portierung der Antwort von @Arnauld auf JavaScript (ES6) .
-2 Bytes dank @ OlivierGrégoire .

Probieren Sie es online aus.

Erläuterung:

n->                 // Method with integer parameter and integer return-type
  f(0,n)            //  Call the recursive method with 0 and this parameter

int f(int r,int n){ // Recursive method with integer as both two parameters and return-type
  return n>0?       //  If `n` is not 0 yet:
    f(r+n,--n)      //   Recursive call with `r+n` (and `n` lowered by 1 first with `--n`)
    +f(r+~n,n)      //   + Recursive call with `r-n` (and `n` also lowered by 1)
   :r==0?           //  Else-if `r` is 0
     1              //   Return 1
    :               //  Else:
     0;}            //   Return 0

Haskell , 55 Bytes

Ein einfacher Ansatz, alle diese Summen zu berechnen und zu überprüfen, wie viele Nullen sind.

f 0=[0]
f n=[(n+),(n-)]>>=(<$>f(n-1))
g x=sum[1|0<-f x]

Probieren Sie es online!

EDIT: @H.PWiz hat eine kürzere und wesentlich elegantere Lösung mit mapM!

Bash + GNU-Dienstprogramme, 63 Bytes

Bash kann wahrscheinlich besser mit rekursiven Funktionen umgehen, aber ich kann dieser Art von eval/ Escape / Expansions-Monstrosität nicht widerstehen :

p=eval\ printf\ %s
$p\\\\n \$[$($p \\\{+,-}{1..$1})]|grep -c ^0

Probieren Sie es online!

Update: Ich glaube nicht, dass Bash mit rekursiven Funktionen besser umgehen kann. Dies ist das Beste, was ich für eine Punktzahl von 90 tun konnte . evalzum Teufel ist es dann.

Brachylog , 12 Bytes

⟦₁{{ṅ|}ᵐ+0}ᶜ

Probieren Sie es online!

Erläuterung

⟦₁               The range [1, …, Input]
  {       }ᶜ     Count the number of times the following predicate succeeds on that range:
   {  }ᵐ           Map for each element of the range:
    ṅ                Negate
     |               Or do nothing
        +0         The sum of the elements after the map is 0

Oktave , 42 Bytes

@(n)sum((dec2bin(0:2^n-1)*2-97)*(1:n)'==0)

Probieren Sie es online!

J , 32 Bytes

1#.0=1#.1+i.*"1[:<:@+:@#:[:i.2^]

Probieren Sie es online!

Es gibt sicherlich viel Platz zum Golfen. Eine Erklärung wird folgen.

Haskell , 41 Bytes

(%0)
n%k|n<1=0^k^2|m<-n-1=m%(k+n)+m%(k-n)

Probieren Sie es online!

Gelee , 10 Bytes

RżN$ŒpS€ċ0

Probieren Sie es online!

Perl 5 , -p35 Bytes

#!/usr/bin/perl -p
$_=grep!eval,glob join"{+,-}",0..$_

Probieren Sie es online!

Pari / GP , 30 Bytes

n->Pol(prod(i=1,n,x^i+x^-i))%x

Probieren Sie es online!

Prolog (SWI) , 99 Bytes

p(0,0,1).
p(0,_,0).
p(X,Y,Z):-A is X-1,B is Y+X,p(A,B,C),D is Y-X,p(A,D,E),Z is C+E.
X*Y:-p(X,0,Y).

Probieren Sie es online!

Pyth, 14 13 Bytes

lf!s.nT*F_BRS

Probieren Sie es hier aus

Erläuterung

lf!s.nT*F_BRS
            SQ  Take the list [1, ..., <implicit input>].
         _BR    Get the pairs [[1, -1], [2, -2], ...].
       *F       Take the Cartesian product.
 f!s.nT         Find the ones where the flattened sum is 0.
l               Take the length.

CJam , 25 Bytes

ri,:)_Wf*:a.+:m*:e_1fb0e=

Probieren Sie es online!

Dies ist eine ziemlich direkte Übersetzung von @ emignas 05AB1E-Lösung. Es ist auf jeden Fall golfen.

Stax , 9 Bytes

è%é┐╬@₧╠¬

Führen Sie es aus und debuggen Sie es

Eine der kürzesten Antworten, die bisher von Jelly besiegt wurden.

Ich bin der Meinung, dass das explizite Überprüfen der Summe der Vorzeichen mit Null nicht sehr schwierig ist. Stattdessen nehme ich den Powerset und überprüfe, wie viele Sätze im Powerset die Summe der Hälfte der n-ten Dreieckszahl haben. Diese Methode ist nicht überraschend zeitaufwändig wie die Überprüfung, welche Vorzeichen sich zu Null addieren.

ASCII-Äquivalent:

RS{|+Hmx|+#

Pyth , 10 Bytes

/mysdySQsS

Probieren Sie es online aus. Alternativ können Sie alle Testfälle auf einmal überprüfen .

Erklärung:

/mysdySQsS    Implicit: Q=input()
      SQ      Generate range [1...Q]
     y        Generate powerset of above
 m            Map d in the above over...
  ysd         ... double the sum of d
        sS    Sum of range [1...Q] (final Q is implicit)
/             Count the matches (implicit output)

J , 28 Bytes

(*>:){1j3#1+//.@(*/)/@,.=@i.

Verwendet die andere Definition von OEIS wo a(n) = coefficient of x^(n(n+1)/4) in Product_{k=1..n} (1+x^k) if n = 0 or 3 mod 4 else a(n) = 0.

Probieren Sie es online!

Erläuterung

(*>:){1j3#1+//.@(*/)/@,.=@i.  Input: n
                          i.  Range [0, n)
                        =     Self-Classify. Forms an identity matrix of order n
          1           ,.      Stitch. Prepend 1 to each row
                    /         Reduce using
                                Convolution
                 */               Product table
           +//.                   Sum along anti-diagonals
      1j3#                    Copy each once, padding with 3 zeroes after
     {                        Index at n*(n+1)
  >:                            Increment n
 *                              Times n

Schale , 9 Bytes

#½Σḣ¹mΣṖḣ

Probieren Sie es online!

Erläuterung

#½Σḣ¹mΣṖḣ  Implicit input
        ḣ  [1..input]
       Ṗ   Powerset
     mΣ    Sum each list
#          Count occurrence of
   ḣ¹        [1..input]
 ½Σ          Half of sum

Gol> <> , 26 Bytes

:IFPlMF2K+}:@-}||0lMF$z+|h

Probieren Sie es online! oder Testfälle von 1 bis 16 ausführen!

Wie es funktioniert

:IFPlMF2K+}:@-}||0lMF$z+|h

Main outer loop
:IFPlMF ...... ||
:        Duplicate top; effectively generate two explicit zeroes
         Top is the loop counter `i`;
         the rest is the generated 2**i sums
 I       Take input as number
  F ........... |  Pop n and loop n times
   P     i++
    lM   Push stack length - 1, which is 2**(i-1)
      F ...... |   Loop 2**(i-1) times

Main inner loop: generate +i and -i from 2**(i-1) previous sums
2K+}:@-}
          Stack: [... x i]
2K        [... x i x i]    Copy top two
  +}      [x+i ... x i]    Add top two and move to the bottom
    :@    [x+i ... i i x]  Duplicate top and rotate top 3
      -}  [i-x x+i ... i]  Subtract and move to the bottom

Counting zeroes
0lMF$z+|h
0lM        Push zero (zero count) and 2**n (loop count)
   F...|   Loop 2**n times
    $z+    Swap top two; Take logical not; add to the count
        h  Print top as number and halt