Mit unseren bekannten mathematischen Symbolen: +, x, Klammern und einer beliebigen rationalen Zahl können Sie leicht Ausdrücke erstellen, die eine gewünschte Zahl ergeben. Zum Beispiel: 1+(2x3)=7, (1+2)+(3x6.5)=22.5und so weiter. Langweilig genug.

In dieser Herausforderung werden wir einen neuen Betreiber benutzen ±. Die Verwendung von ±in einem Ausdruck bedeutet, dass Sie den Ausdruck auswerten müssen, indem Sie die ±durch +oder -auf alle möglichen Arten ersetzen und die Menge aller möglichen Werte zurückgeben. Beispielsweise:

• 1±2±3 = {-4,0,2,6}da 1±2±3kann jeder sein 1+2+3, 1+2-3, 1-2+3und 1-2-3und ihre Werte 6,0,2,-4sind.
• (±2)x(2±3) = {-10,-2,2,10} aus ähnlichen Gründen.

Nun, wie sich herausstellt, da jeder Satz von verschiedenen reellen Zahlen, ist es möglich , einen Ausdruck mit schaffen +, x, (, ), ±, und reellen Zahlen , dass auswertet zu dem vorgegebenen Satz.

Aufgabe

Ihre Aufgabe ist es, ein Programm oder eine Funktion in der Sprache Ihrer Wahl zu schreiben, die eine Sequenz dauert (Liste / array / jedes geeignetes Format) von ganzen Zahlen und gibt einen Ausdruck (als String) aus +, x, (, ), ±, und rationaler Zahlen das ergibt die Menge der gegebenen Zahlen.

• Beachten Sie, dass das genaue Zeichen ±keine Rolle spielt. Sie können jedes andere Zeichen Ihrer Wahl verwenden, sofern es von den anderen Zeichen, die Sie verwenden, unterscheidbar ist. Sie müssen jedoch angeben, welchen Charakter Sie in Ihrer Einreichung verwenden.
• Die Eingabe darf aus Dezimalnäherungen (bis zu einer angemessenen Genauigkeit) der verwendeten rationalen Zahlen bestehen.
• Die Ein- und Ausgabe kann auf eine der üblichen Arten erfolgen.
• Standardlücken sind verboten.
• Sie können davon ausgehen, dass die angegebenen Ganzzahlen unterschiedlich sind und in aufsteigender Reihenfolge angegeben werden.
• Die Ausgabe kann Leerzeichen und Zeilenumbrüche enthalten.

Gewinnkriterium

Das ist Code-Golf , also gewinnt der kürzeste Code in Bytes.

Beispiele

Eingabe | Mögliche Ausgabe
------------- + -----------------------------
[1,2,3] | 2 ± 0,5 ± 0,5                   
[-7, -3,1,21] | (1 ± 2) x (3 ± 4)

_{Idee aus einer Frage des Städteturniers, Herbst 2015 .}

Python 2 , 56 Bytes

f=lambda h,*t:t and"(.5?.5)*(%s+%%s)+"%f(*t)%-h+`h`or`h`

Probieren Sie es online!

Das ?steht für ±. Anwendungsbeispiel:

f(-3,5,20) ->
(.5?.5)*((.5?.5)*(20+-5)+5+3)+-3

Die Idee ist, dass wir einen Ausdruck nehmen Eund einen neuen Wert han seine Wertemenge anhängen können, indem wir tun (.5±.5)*(E+-h)+h.

Haskell , 52 Bytes

f(h:t)=shows h"+(.5?.5)*("++f[x-h|x<-t]++")"
f e="0"

Probieren Sie es online!

Verwendet ?für ±. Beispiel:

f [1,3,7] ->
1+(.5?.5)*(2+(.5?.5)*(4+(.5?.5)*(0)))

Die Funktion showsfunktioniert shows a b=(show a)++b, ein Trick, den ich von Lynn gelernt habe.

shows 12 "abc" ->
"12abc"

Haskell , 58 Bytes

Verwenden #für ±, da es ein Byte weniger ist.

f Nimmt eine Liste von Ganzzahlen und gibt eine Zeichenfolge zurück.

f[x]=show x
f(x:r)=show x++"+(.5#.5)x("++f((-x+)<$>r)++")"

Das Ergebnis ist von der Form n+(.5#.5)x(rest), in der ndas erste Element der Liste und restdie Darstellung aller anderen Elemente mit jeweils nabgezogen wird.

Probieren Sie es online!

Gelee , 29 Bytes

“(¤)”j.⁾+×j;”(
I;@Ḣj¢;”)ẋ⁸L¤¤

Drucke v + (0.5¤0.5) × (i ₁ + (0.5¤0.5) × ((i ₂ + (0.5¤0.5) x (... (i _n ) ...))) wobei v ist die erste Zahl in die Eingangsanordnung und i _n ist die n - ^te inkrementale Differenz zwischen den Elementen des Eingangs - Array.

Probieren Sie es online!

Wie?

“(¤)”j.⁾+×j;”( - Link 1, adjoining list: no input
“(¤)”          - literal     ['(','¤',')']
      .        - literal     0.5
     j         - join        ['(',0.5,'¤',0.5,')']
       ⁾+×     - literal     ['+','×']
          j    - join        ['+',['(',0.5,'¤',0.5,')'],'×']
            ”( - literal     '('
           ;   - concatenate ['+',['(',0.5,'¤',0.5,')'],'×','(']

I;@Ḣj¢;”)ẋ⁸L¤¤ - Main link: list a               e.g. [-1,5,2]
I              - incremental differences(a)           [6,-3]
   Ḣ           - head(a)                              [-1]
 ;@            - concatenate (rev @rgs)               [-1,6,-3]
     ¢         - last link (1) as a nilad             ['+',['(',0.5,'¤',0.5,')'],'×','(']
    j          - join                                 [-1,['+',['(',0.5,'¤',0.5,')'],'×','('],6,['+',['(',0.5,'¤',0.5,')'],'×','('],-3]
             ¤ - nilad followed by link(s) as a nilad
            ¤  -     nilad followed by link(s) as a nilad
          ⁸    -         link's left argument, a
           L   -         length                       3
       ”)      -     literal ')'
         ẋ     -     repeat                           [')',')',')']
      ;        - concatenate                          [-1,['+',['(',0.5,'¤',0.5,')'],'×','('],6,['+',['(',0.5,'¤',0.5,')'],'×','('],-3,')',')',')']
               - implicit print                       -1+(0.5¤0.5)×(6+(0.5¤0.5)×(-3))

05AB1E , 25 Bytes

0¸«¥X;D"+(ÿ±ÿ)*("ý¹g<')×J

Probieren Sie es online!

Erläuterung

0¸«                        # prepend a 0 to input list
   ¥                       # calculate delta's
    X;D                    # push 0.5 twice
       "+(ÿ±ÿ)*("          # push this string and interpolate 0.5 where "ÿ" is
                 ý         # merge the list of delta's with this string as a separator
                  ¹g<')×J  # add the closing parenthesis

Das Bilden des Ausdrucks von rechts endet leider damit, dass die gleiche Byteanzahl mit
0¸«¥¤s¨RvX;Dy"ÿ+(ÿ±ÿ)*(ÿ). Die 8 Bytes, die für das Setup verwendet werden, sind hier die große Verschwendung.

Haskell, 54 Bytes

f[]="0"
f(x:s)=show x++"+(.5?.5)*("++f(map(-x+)s)++")"

das + - Zeichen ist '?'. Beispiel:

f[1,2,3,4] = "1+(.5#.5)*(1+(.5#.5)*(1+(.5#.5)*(1+(.5#.5)*(0))))"

JavaScript (ES6), 56 51 Byte

f=([v,...a],x=v)=>x?x+`+(.5@.5)*(${f(a,a[0]-v)})`:0

Basierend auf der Formel von @ JonathanAllan. @steht für ±.