Escribir un programa o función que dado n ≥ 1 devuelve el número de soluciones a ± 1 ± 2 ± 3 ± ... ± n = 0.

Para n = 6 no hay soluciones, entonces la respuesta es 0. Para n = 4 hay dos soluciones, entonces la respuesta es 2 (las dos soluciones son 1 - 2 - 3 + 4 = -1 + 2 + 3 - 4 = 0).

Esta es la secuencia OEIS A063865 . Algunos ejemplos de entrada / salida son:

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

El código más corto en bytes gana.

JavaScript (ES6), 35 bytes

Guardado 1 byte gracias a @tsh

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

Pruébalo en línea!

Wolfram Language (Mathematica) , 33 bytes

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

Cuenta las ntuplas de 1 y -1 cuyo producto de punto Range[n]es 0.

Pruébalo en línea!

Haskell , 42 bytes

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

Pruébalo en línea!

Esto es 2 1 byte más corto que cualquier función recursiva que podría escribir.

05AB1E , 10 bytes

X®‚sã€ƶO_O

Pruébalo en línea!

Explicación

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

Puerto de la respuesta Java 8 de Kevin Cruijssen .

Pruébelo en línea aquí .

Tenga en cuenta que debido a las mejoras sugeridas en los comentarios, el código produce un comportamiento indefinido hasta el punto de no funcionar cuando se compila con clang.

Gracias a etene por jugar al golf 3 bytes. Gracias a Kevin Cruijssen por jugar 10 bytes más. Gracias a Christoph por jugar al golf otros 2 bytes.

Versión sin golf:

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

¡Gracias a Emigna por guardar un byte!

Código:

LæO·sLO¢

Utiliza el codificación 05AB1E . Pruébalo en línea!

Explicación

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

¡Gracias a @Giuseppe por guardar 1 byte!

Pruébalo en línea! O verificar todos los casos de prueba .

Explicación

Considere n = 3como un ejemplo. La pila se muestra al revés, es decir, la más nueva aparece a continuación.

[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

Jalea , 8 bytes

ŒPS€ċÆṁ$

Pruébalo en línea!

Cómo funciona

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

Más de una presentación divertida, cálculo de la función de generación directa.

Octava (con paquete de comunicaciones), 39 bytes

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

Pruébalo en línea!

Explicación:

Tome un rango 0 ... n ^ 2-1 y conviértalo a binario. Esto proporciona una matriz con todas las combinaciones de 0 y 1 . Multiplique por 2 y reste 1 para obtener una matriz con todas las combinaciones de -1 y +1 .

Tome el producto punto con un rango de 1 ... n para obtener todas las combinaciones de ± 1 ± 2 ... ± n . Cuenta cuántos son cero.

Básicamente lo mismo, el mismo número de bytes:

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

APL (Dyalog) , 31 22 bytes

9 bytes guardados gracias a @ H.PWiz

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

Pruébalo en línea!

Python 2 y 3, 50 bytes

Enfoque recursivo como la mayoría de las respuestas:

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

Pruébalo en línea

La llamada recursiva doble toma demasiados bytes ... Probablemente haya una manera de simplificarla.

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

Puerto de la respuesta de JavaScript de @Arnauld (ES6) .
-2 bytes gracias a @ OlivierGrégoire .

Pruébalo en línea.

Explicación:

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

Un enfoque directo de calcular todas esas sumas y verificar cuántas son cero.

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

Pruébalo en línea!

EDITAR: @ ​​H.PWiz tiene una solución más corta y mucho más elegante usando mapM!

Bash + utilidades GNU, 63 bytes

Bash probablemente puede hacerlo mejor que esto con funciones recursivas, pero no puedo resistir este tipo de evalmonstruosidad / escape / expansión:

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

Pruébalo en línea!

Actualización: no creo que bash pueda funcionar mejor con funciones recursivas. Esto es lo mejor que puedo hacer por un puntaje de 90 . evaldiablos es entonces.

Brachylog , 12 bytes

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

Pruébalo en línea!

Explicación

⟦₁               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

Octava , 42 bytes

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

Pruébalo en línea!

J , 32 bytes

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

Pruébalo en línea!

Ciertamente hay mucho espacio para jugar al golf. La expansión seguirá.

Haskell , 41 bytes

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

Pruébalo en línea!

Jalea , 10 bytes

RżN$ŒpS€ċ0

Pruébalo en línea!

Perl 5 , -p35 bytes

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

Pruébalo en línea!

Pari / GP , 30 bytes

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

Pruébalo en línea!

Prólogo (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).

Pruébalo en línea!

Pyth, 14 13 bytes

lf!s.nT*F_BRS

Pruébalo aquí

Explicación

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=

Pruébalo en línea!

Esta es una traducción bastante directa de la solución 05AB1E de @emigna. Ciertamente es golfable.

Stax , 9 bytes

è%é┐╬@₧╠¬

Ejecutar y depurarlo

Una de las respuestas más cortas hasta ahora. derrotada por Jelly.

Siento que verificar explícitamente qué signos suman cero no es muy complejo, por lo que tomo el conjunto de potencia y compruebo cuántos conjuntos del conjunto de potencia tienen la suma de la mitad del enésimo número triangular. Este método es, no sorprendentemente, de la misma complejidad de tiempo que verificar qué signos suman cero.

ASCII equivalente:

RS{|+Hmx|+#

Pyth , 10 bytes

/mysdySQsS

Pruébalo en línea. Alternativamente, verifique todos los casos de prueba a la vez .

Explicación:

/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.

Utiliza la otra definición de OEIS where 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.

Pruébalo en línea!

Explicación

(*>:){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

Casco , 9 bytes

#½Σḣ¹mΣṖḣ

Pruébalo en línea!

Explicación

#½Σḣ¹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

Pruébalo en línea! o ¡ Ejecute casos de prueba del 1 al 16!

Cómo funciona

: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