Inspiriert von dieser Antwort (Hervorhebung von mir):

Wir werden ein Spiel spielen. Angenommen, Sie haben eine Zahl x . Sie beginnen mit x und können dann eine beliebige Ganzzahl außer Null addieren, subtrahieren, multiplizieren oder dividieren. Sie können auch mit x multiplizieren . Sie können diese Dinge so oft tun, wie Sie möchten. Wenn die Summe Null wird, gewinnen Sie.

Angenommen, x ist 2/3. Mit 3 multiplizieren und dann 2 subtrahieren. Das Ergebnis ist Null. Du gewinnst!

Angenommen, x ist 7 ^ (1/3). Multiplizieren Sie mit x , dann erneut mit x und subtrahieren Sie 7. Sie gewinnen!

Angenommen, x ist √2 + √3. Hier ist es nicht leicht zu sehen, wie man gewinnt. Es stellt sich jedoch heraus, dass Sie gewinnen, wenn Sie mit x multiplizieren , 10 subtrahieren, zweimal mit x multiplizieren und 1 addieren. (Dies sollte nicht offensichtlich sein; Sie können es mit Ihrem Taschenrechner versuchen.)

Wenn Sie jedoch mit x = π beginnen, können Sie nicht gewinnen. Es gibt keine Möglichkeit, von π nach 0 zu gelangen, wenn Sie addieren, subtrahieren, multiplizieren oder durch ganze Zahlen dividieren oder mit π multiplizieren, unabhängig davon, wie viele Schritte Sie ausführen. (Dies sollte auch nicht offensichtlich sein. Es ist eine sehr knifflige Sache!)

Zahlen wie √2 + √3, aus denen Sie gewinnen können, werden als algebraisch bezeichnet . Zahlen wie π, mit denen man nicht gewinnen kann, heißen transzendent.

Warum ist das interessant? Jede algebraische Zahl ist arithmetisch mit den ganzen Zahlen verknüpft, und die Gewinnzüge im Spiel zeigen Ihnen, wie dies geschieht. Der Weg zu Null mag lang und kompliziert sein, aber jeder Schritt ist einfach und es gibt einen Weg. Transzendentale Zahlen unterscheiden sich jedoch grundlegend: Sie sind nicht über einfache Schritte arithmetisch mit den ganzen Zahlen verbunden.

Im Wesentlichen werden Sie die in der oben genannten Frage verwendeten Schritte verwenden, um das Spiel für eine bestimmte Eingabe zu "gewinnen".

xKonvertieren Sie bei einer reellen algebraischen Konstante die Zahl mit den folgenden zulässigen Operationen in Null:

• Addiere oder subtrahiere eine ganze Zahl.
• Multiplizieren oder dividieren Sie mit einer Ganzzahl ungleich Null.
• Mit der ursprünglichen Konstante multiplizieren x.

Die Eingabe ist eine Zeichenfolge, die Ganzzahlen, Addition, Subtraktion, Multiplikation, Division, Exponentiation (Exponenten Ihrer Wahl **oder ^Exponenten werden zur Darstellung von Wurzeln verwendet) und Klammern enthalten kann. Leerzeichen in der Eingabe sind optional, jedoch nicht in der Ausgabe. Sie sollten die Schritte ausgeben, die erforderlich sind, um ein Ergebnis von Null zu erhalten, sodass das Multiplizieren mit 7einem Schritt als ausgegeben wird *7. Ein Leerzeichen und / oder eine neue Zeile ist zulässig.

Beispiele

0               ->  +0 (or any other valid, or empty)
5/7 + 42        ->  -42 *7 -5 (or shorter: *7 -299)
2^(1/3)         ->  *x *x -2
5*(3**(1/4))    ->  *x *x *x -1875
2^(1/2)+3^(1/2) ->  *x -10 *x *x +1

Der kürzeste Code gewinnt.

SageMath , 108 Bytes

def f(s):p=map('{:+} '.format,numerator(minpoly(sage_eval(s)/1)));return'*'+p[-1][1:]+'*x '.join(p[-2::-1])

Probieren Sie es auf SageMathCell aus .

Erläuterung:

Bewerten Sie die Zeichenfolge symbolisch als algebraische Zahl ( sage_eval()). Jede algebraische Zahl ist eine Null eines Polynoms a [0] + a [1] x ^ 1 + a [2] x ^ 2 + ⋯ + a [n] x ^ n mit rationalen Koeffizienten a [0],…, a [ n ] ( minpoly()). Multiplizieren Sie alle Koeffizienten mit ihrem gemeinsamen Nenner, um sie in Ganzzahlen ( numerator()) umzuwandeln, und schreiben Sie dieses Polynom in das gewünschte Ausgabeformat.

*a[n] +a[n-1] *x +a[n-2] *x … *x +a[1] *x +a[0]

SageMath, fast 102 Bytes

lambda s:(lambda a,*p:'*%d'%a+'*x'.join(map(' {:+} '.format,p)))(*numerator(minpoly(1/sage_eval(s))))

Dies funktioniert für alle Eingaben außer 0, da ein Polynom für 1 / α ein Polynom für α ist, wobei die Koeffizienten umgekehrt sind. :-(

Mathematica, 194 224 192 Bytes

""<>Cases[HornerForm@MinimalPolynomial[ToExpression@#,x]//.{Times->t,x^a_:>Fold[#2~t~#&,x~Table~a],a_~t~b_~t~c_:>a~t~t[b,c]},a_~b_~_:>{b/.t:>"*"/.Plus:>If[a>0,"+",""],ToString@a," "},{0,∞}]&

Hier ∞ist das Drei-Byte-Unicode-Zeichen, das die Unendlichkeit in Mathematica darstellt.

Da die Eingabe eine Zeichenfolge ist, gehen 13 Bytes verloren, ToExpression@die die Zeichenfolgeneingabe als algebraischen Ausdruck interpretieren.

HornerForm@MinimalPolynomial[2^(1/2)+3^(1/2), x]

Würde so etwas wie zurückgeben

1 + x^2 (-10 + x^2)

Die nächste Ersetzungsregel massiert dies in etwas, das strukturell ähnlich ist

1 + (x * (x * (-10 + (x * (x)))))

Diese Horner-Form kann wie ein Baum dargestellt werden:

Nach den Regeln von OP beginnen wir mit dem tiefsten Blatt rechts.

Cases geht den Ausdruck durch, beginnend auf der tiefsten Ebene, nimmt jeden übergeordneten Knoten und sein linkes Blatt und setzt diesen zu einer Tabelle wie z

"*" "x"   " "
""  "-10" " "
"*" "x"   " "
"*" "x"   " "
"+" "1"   " "

""<> verkettet alles mit der leeren Zeichenfolge.