Desafío

El desafío es escribir un código que tome un entero positivo 'n' como entrada y muestre todas las formas posibles en que se pueden escribir los números del 1 - n, con signo positivo o negativo en el medio, de modo que su suma sea igual a cero Recuerde que solo puede usar sumas o restas.

Por ejemplo, si la entrada es 3, entonces hay 2 formas de hacer que la suma sea 0:

 1+2-3=0
-1-2+3=0

Tenga en cuenta que los números están en orden, comenzando desde 1 hasta n (que es 3 en este caso). Como es evidente en el ejemplo, el signo del primer número también puede ser negativo, así que tenga cuidado.

Ahora, 3 era bastante simple. Hagamos una lista de todas las formas cuando consideramos el número 7.

 1+2-3+4-5-6+7=0
 1+2-3-4+5+6-7=0
 1-2+3+4-5+6-7=0
 1-2-3-4-5+6+7=0
-1+2+3+4+5-6-7=0
-1+2-3-4+5-6+7=0
-1-2+3+4-5-6+7=0
-1-2+3-4+5+6-7=0

Entonces, aquí tenemos un total de 8 formas posibles.

Entrada y salida

Como se indicó anteriormente, la entrada sería un número entero positivo . Su salida debe contener todas las formas posibles en que los números dan una suma de cero. En caso de que no haya una manera posible de hacer lo mismo, puede generar lo que desee.

Además, puede imprimir la salida en cualquier formato que desee . Pero, debería ser comprensible . Por ejemplo, puede imprimirlo como en el ejemplo anterior. O bien, puede imprimir los signos de los números en orden. De lo contrario, también puede imprimir '0' y '1' en orden, donde '0' mostrará un signo negativo y '1' mostrará un signo positivo (o viceversa).

Por ejemplo, puede representar 1 + 2-3 = 0 usando:

1+2-3=0
1+2-3
[1,2,-3]
++-
110
001    

Sin embargo, recomendaría usar cualquiera de los primeros tres formatos por simplicidad. Puede asumir que todas las entradas son válidas.

Ejemplos

7 ->

 1+2-3+4-5-6+7=0
 1+2-3-4+5+6-7=0
 1-2+3+4-5+6-7=0
 1-2-3-4-5+6+7=0
-1+2+3+4+5-6-7=0
-1+2-3-4+5-6+7=0
-1-2+3+4-5-6+7=0
-1-2+3-4+5+6-7=0

4 ->

 1-2-3+4=0
-1+2+3-4=0

2 -> -

8 ->

 1+2+3+4-5-6-7+8=0
 1+2+3-4+5-6+7-8=0
 1+2-3+4+5+6-7-8=0
 1+2-3-4-5-6+7+8=0
 1-2+3-4-5+6-7+8=0
 1-2-3+4+5-6-7+8=0
 1-2-3+4-5+6+7-8=0
-1+2+3-4+5-6-7+8=0
-1+2+3-4-5+6+7-8=0
-1+2-3+4+5-6+7-8=0
-1-2+3+4+5+6-7-8=0
-1-2+3-4-5-6+7+8=0
-1-2-3+4-5+6-7+8=0
-1-2-3-4+5+6+7-8=0

Puntuación

Este es el código de golf , por lo que gana el código más corto.

Haskell , 42 bytes

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

Pruébalo en línea!

Jalea , 9 bytes

1,-ṗ×RSÐḟ

Pruébalo en línea!

Exp

1,-ṗ×RSÐḟ  Main link. Input = n. Assume n=2.
1,-        Literal list [1, -1].
   ṗ       Cartesian power n. Get [[1, 1], [1, -1], [-1, 1], [-1, -1]]
    ×R     Multiply (each list) by Range 1..n.
       Ðḟ  ḟilter out lists with truthy (nonzero)
      S      Sum.

Jalea , 9 bytes

La sugerencia de Jonathan Allan , muestra una lista de señales.

1,-ṗæ.ÐḟR

Pruébalo en línea!

Python 2 , 62 bytes

f=lambda n,*l:f(n-1,n,*l)+f(n-1,-n,*l)if n else[l]*(sum(l)==0)

Pruébalo en línea!

El Sr. Xcoder ahorró 4 bytes con un ingenioso uso de argumentos destacados.

Perl, 37 36 bytes

perl -E 'map eval||say,glob join"{+,-}",0..<>' <<< 7

05AB1E , 11 bytes

®X‚¹ãʒ¹L*O_

Pruébalo en línea!

El formato de salida para, por ejemplo, la entrada 3es:

[[-1, -1, 1], [1, 1, -1]]

Es decir, -1-2+3, 1+2-3.

Wolfram Language (Mathematica) , 36 bytes

Pick[p={1,-1}~Tuples~#,p.Range@#,0]&

Pruébalo en línea!

Casco , 10 bytes

fo¬ΣΠmSe_ḣ

Pruébalo en línea!

Explicación

No muy complicado

fo¬ΣΠmSe_ḣ  Implicit input, say n=4
         ḣ  Range: [1,2,3,4]
     m      Map over the range:
      Se     pair element with
        _    its negation.
            Result: [[1,-1],[2,-2],[3,-3],[4,-4]]
    Π       Cartesian product: [[1,2,3,4],[1,2,3,-4],..,[-1,-2,-3,-4]]
f           Keep those
   Σ        whose sum
 o¬         is falsy (equals 0): [[-1,2,3,-4],[1,-2,-3,4]]

Python 3 , 105 bytes

lambda n:[k for k in product(*[(1,-1)]*n)if sum(-~n*s for n,s in enumerate(k))==0]
from itertools import*

Pruébalo en línea!

Rápido , 116 bytes

func f(n:Int){var r=[[Int]()]
for i in 1...n{r=r.flatMap{[$0+[i],$0+[-i]]}}
print(r.filter{$0.reduce(0){$0+$1}==0})}

Pruébalo en línea!

Explicación

func f(n:Int){
  var r=[[Int]()]                         // Initialize r with [[]]
                                          // (list with one empty list)
  for i in 1...n{                         // For i from 1 to n:
    r=r.flatMap{[$0+[i],$0+[-i]]}         //   Replace every list in r with the list
  }                                       //   prepended with i and prepended with -i
  print(r.filter{$0.reduce(0){$0+$1}==0}) // Print all lists in r that sums to 0
}

Python 2 , 91 bytes

lambda x:[s for s in[[~j*[1,-1][i>>j&1]for j in range(x)]for i in range(2**x)]if sum(s)==0]

Pruébalo en línea!

Devuelve una lista de listas satisfactorias (p. Ej., F (3) = [[- 1, -2,3], [1,2, -3]])

APL (Dyalog) , 38 bytes

{k/⍨0=+/¨k←((,o∘.,⊢)⍣(⍵-1)⊢o←¯1 1)×⊂⍳⍵}

Pruébalo en línea!

Pyth , 13 bytes

f!sT.nM*F_BMS

Pruébalo aquí!

C (gcc) , 171 bytes

k,s;f(S,n,j)int*S;{if(j--)S[j]=~0,f(S,n,j),S[j]=1,f(S,n,j);else{for(s=k=0;k<n;k++)s+=S[k]*-~k;if(!s&&puts(""))for(k=0;k<n;)printf("%d",S[k++]+1);}}F(n){int S[n];f(S,n,n);}

Pruébalo en línea! Usos 0para 2signos negativos y positivos.

Limpio , 79 bytes

import StdEnv
$n=[k\\k<-foldr(\i l=[[p:s]\\s<-l,p<-[~i,i]])[[]][1..n]|sum k==0]

Pruébalo en línea!

Python 3 + numpy, 104 103 bytes

import itertools as I,numpy as P
lambda N:[r for r in I.product(*[[-1,1]]*N)if sum(P.arange(N)*r+r)==0]

La salida es [-1, 1] correspondiente al signo.

JavaScript (ES6), 69 61 bytes

Ahorró 8 bytes al deshacerse de k , como lo sugiere @Neil

Imprime todas las soluciones con alert () .

f=(n,o='')=>n?f(n-1,o+'+'+n)&f(n-1,o+'-'+n):eval(o)||alert(o)

Casos de prueba

Usando console.log () en lugar de alert () para facilidad de uso.

f=(n,o='')=>n?f(n-1,o+'+'+n)&f(n-1,o+'-'+n):eval(o)||alert(o)

alert = console.log;

console.log('[7]');f(7)
console.log('[4]');f(4)
console.log('[2]');f(2)
console.log('[8]');f(8)

Retina , 73 bytes

.+
*
_
=_$`
+0`=
-$%"+
(-(_)+|\+(_)+)+
$&=$#2=$#3=
G`(=.+)\1=
=.*

_+
$.&

Pruébalo en línea! Explicación:

.+
*

Convierta la entrada a unario.

_
=_$`

Convierta el número a una lista de =números prefijados.

+0`=
-$%"+

Reemplace cada uno =a su vez con ambos -y +, duplicando el número de líneas cada vez.

(-(_)+|\+(_)+)+
$&=$#2=$#3=

Cuente por separado el número de _s después de -sy +s. Esto suma los números negativos y positivos.

G`(=.+)\1=

Mantener sólo aquellas líneas en las que los -s y +s se cancelan.

=.*

Eliminar los recuentos.

_+
$.&

Convierte a decimal.

Perl 6 , 43 bytes

{grep *.sum==0,[X] (1..$_ X*1,-1).rotor(2)}

Pruébelo
Devuelve una secuencia de listas

Expandido:

{  # bare block lambda with implicit parameter ｢$_｣

  grep              # only return the ones
    *.sum == 0,     # that sum to zero

    [X]             # reduce with cross meta operator

      (
          1 .. $_   # Range from 1 to the input

        X*          # cross multiplied by

          1, -1

      ).rotor(2)    # take 2 at a time (positive and negative)
}

1..$_ X* 1,-1⇒ (1, -1, 2, -2)
(…).rotor(2)⇒ ((1, -1), (2, -2))
[X] …⇒((1, 2), (1, -2), (-1, 2), (-1, -2))

J , 35 30 bytes

-5 bytes gracias a FrownyFrog!

>:@i.(]#~0=1#.*"1)_1^2#:@i.@^]

Pruébalo en línea!

Original:

J , 35 bytes

[:(#~0=+/"1)>:@i.*"1(_1^[:#:@i.2^])

Cómo funciona

Multiplico la lista 1..n con todas las listas posibles de coeficientes 1 / -1 y encuentro las que suman cero.

                    (             ) - the list of coefficients
                             i.     - list 0 to 
                               2^]  - 2 to the power of the input
                     _1^[:          - -1 to the power of 
                          #:@       - each binary digit of each number in 0..n-1 to 
                 *"1                - each row multiplied by
            >:@i.                   - list 1..n
  (#~      )                        - copy those rows
     0=+/"1                         - that add up to 0
[:                                  - compose   

Pruébalo en línea!

Como alternativa probé un verbo explícito, utilizando el enfoque del producto cartesiano de +/-:

J , 37 bytes

3 :'(#~0=+/"1)(-y)]\;{(<"1@,.-)1+i.y'

{(<"1@,.-) encuentra los productos cartesianos, por ejemplo:

{(<"1@,.-) 1 2 3
┌───────┬────────┐
│1 2 3  │1 2 _3  │
├───────┼────────┤
│1 _2 3 │1 _2 _3 │
└───────┴────────┘

┌───────┬────────┐
│_1 2 3 │_1 2 _3 │
├───────┼────────┤
│_1 _2 3│_1 _2 _3│
└───────┴────────┘

Lástima que encajone el resultado, así que pasé algunos bytes para desempaquetar los valores

Pruébalo en línea!