Herausforderung

Die Herausforderung besteht darin, einen Code zu schreiben, der eine positive Ganzzahl 'n' als Eingabe verwendet und alle möglichen Arten anzeigt, wie die Zahlen von 1 - n mit einem positiven oder negativen Vorzeichen dazwischen geschrieben werden können, so dass ihre Summe gleich ist gleich Null. Bitte denken Sie daran, dass Sie nur Addition oder Subtraktion verwenden dürfen.

Wenn die Eingabe beispielsweise 3 ist, gibt es zwei Möglichkeiten, die Summe zu 0 zu machen:

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

Beachten Sie, dass die Zahlen von 1 bis n (in diesem Fall 3) geordnet sind. Wie aus dem Beispiel hervorgeht, kann das Vorzeichen der ersten Zahl auch negativ sein. Seien Sie also vorsichtig.

Nun, 3 war ziemlich einfach. Lassen Sie uns alle Möglichkeiten auflisten, wenn wir die Zahl 7 betrachten.

 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

Hier haben wir also insgesamt 8 Möglichkeiten.

Eingabe und Ausgabe

Wie bereits erwähnt, wäre die Eingabe eine positive ganze Zahl . Ihre Ausgabe sollte alle möglichen Arten enthalten, in denen die Zahlen eine Summe von Null ergeben. Falls dies nicht möglich ist , können Sie alles ausgeben, was Sie möchten.

Außerdem können Sie die Ausgabe in einem beliebigen Format drucken Sie möchten . Aber es sollte verständlich sein . Beispielsweise können Sie es wie in dem obigen Beispiel drucken. Oder Sie drucken einfach die Zeichen der Zahlen in der angegebenen Reihenfolge. Andernfalls können Sie auch '0' und '1' in der angegebenen Reihenfolge ausgeben, wobei '0' ein negatives Vorzeichen und '1' ein positives Vorzeichen anzeigt (oder umgekehrt).

Sie können beispielsweise 1 + 2-3 = 0 darstellen, indem Sie Folgendes verwenden:

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

Der Einfachheit halber würde ich jedoch empfehlen, eines der ersten drei Formate zu verwenden. Sie können davon ausgehen, dass alle Eingaben gültig sind.

Beispiele

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

Wertung

Das ist Code-Golf , also gewinnt der kürzeste Code!

Haskell , 42 Bytes

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

Probieren Sie es online!

Gelee , 9 Bytes

1,-ṗ×RSÐḟ

Probieren Sie es online!

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.

Gelee , 9 Bytes

Jonathan Allans Vorschlag, eine Liste von Zeichen auszugeben.

1,-ṗæ.ÐḟR

Probieren Sie es online!

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)

Probieren Sie es online!

Mr. Xcoder sparte 4 Bytes mit einer raffinierten Verwendung von markierten Argumenten.

Perl, 37 36 Bytes

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

05AB1E , 11 Bytes

®X‚¹ãʒ¹L*O_

Probieren Sie es online!

Das Ausgabeformat für zB Eingabe 3ist:

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

Das heißt, -1-2+3, 1+2-3.

Wolfram Language (Mathematica) , 36 Byte

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

Probieren Sie es online!

Schale , 10 Bytes

fo¬ΣΠmSe_ḣ

Probieren Sie es online!

Erläuterung

Nicht zu kompliziert.

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*

Probieren Sie es online!

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

Probieren Sie es online!

Erläuterung

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]

Probieren Sie es online!

Gibt eine Liste mit befriedigenden Listen zurück (z. B. f (3) = [[- 1, -2,3], [1,2, -3]])

APL (Dyalog) , 38 Bytes

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

Probieren Sie es online!

Pyth , 13 Bytes

f!sT.nM*F_BMS

Probieren Sie es hier aus!

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

Probieren Sie es online! Verwendet 0für negative und 2für positive Vorzeichen.

Sauber , 79 Bytes

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

Probieren Sie es online!

Python 3 + Anzahl, 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]

Die Ausgabe ist [-1, 1] entsprechend dem Vorzeichen.

JavaScript (ES6), 69 61 Bytes

8 Bytes gespart, indem k entfernt wurde , wie von @Neil vorgeschlagen

Druckt alle Lösungen mit alert () .

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

Testfälle

Verwenden Sie console.log () anstelle von alert (), um die Benutzerfreundlichkeit zu verbessern .

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)

Netzhaut , 73 Bytes

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

_+
$.&

Probieren Sie es online! Erläuterung:

.+
*

Konvertieren Sie die Eingabe in Unary.

_
=_$`

Konvertieren Sie die Nummer in eine Liste mit =vordefinierten Nummern.

+0`=
-$%"+

Ersetzen Sie die Zeilen =nacheinander durch beide -und +und duplizieren Sie die Anzahl der Zeilen jedes Mal.

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

Zählen Sie getrennt die Anzahl der _s nach -s und +s. Dies summiert die negativen und positiven Zahlen.

G`(=.+)\1=

Behalten Sie nur die Zeilen bei, in denen sich die -Buchstaben s und +s aufheben.

=.*

Löschen Sie die Zählungen.

_+
$.&

In Dezimalzahl konvertieren.

Perl 6 , 43 Bytes

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

Try it
Gibt eine Folge von Listen zurück

Erweitert:

{  # 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 dank FrownyFrog!

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

Probieren Sie es online!

Original:

J , 35 Bytes

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

Wie es funktioniert

Ich multipliziere die Liste 1..n mit allen möglichen Listen der Koeffizienten 1 / -1 und finde diejenigen, die sich zu Null addieren.

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

Probieren Sie es online!

Als Alternative habe ich ein explizites Verb ausprobiert, wobei ich das kartesische Produkt von +/- verwendete:

J , 37 Bytes

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

{(<"1@,.-) findet die kartesischen Produkte zum Beispiel:

{(<"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│
└───────┴────────┘

Schade, dass es das Ergebnis boxt, also habe ich einige Bytes ausgegeben, um die Werte zu entpacken

Probieren Sie es online!