Berechnen Sie den Ultraradikalen

24

Was ist der Ultraradikal

Der Ultraradikal oder das Bring-Radikal einer reellen Zahl $a$ ist definiert als die einzige reelle Wurzel der Quintingleichung $x^5+x+a=0$ .

Hier verwenden wir $UR(\cdot)$ , um die Ultraradikalfunktion zu bezeichnen. Zum Beispiel ist , da . $UR(-100010)=10$ $10^5+10-100010=0$

Herausforderung

Schreiben Sie ein vollständiges Programm oder eine Funktion, die eine reelle Zahl als Eingabe verwendet und deren Ultraradikal zurückgibt oder ausgibt.

Bedarf

Es sind keine Standardlücken erlaubt. Die Ergebnisse für die folgenden Testfälle müssen auf mindestens 6 signifikante Stellen genau sein. Im Allgemeinen sollte das Programm jedoch die entsprechenden Werte für alle gültigen reellen Zahleneingaben berechnen.

Testfälle

Als Referenz werden 9 auf 0 gerundete Dezimalstellen angegeben. Für einige Testfälle wurde eine Erklärung hinzugefügt.

 a                         | UR(a)
---------------------------+---------------------
             0             |   0.000 000 000        # 0
             1             |  -0.754 877 (666)      # UR(a) < 0 when a > 0
            -1             |   0.754 877 (666)      # UR(a) > 0 when a < 0
             1.414 213 562 |  -0.881 616 (566)      # UR(sqrt(2))
            -2.718 281 828 |   1.100 93(2 665)      # UR(-e)
             3.141 592 653 |  -1.147 96(5 385)      # UR(pi)
            -9.515 716 566 |   1.515 71(6 566)      # 5th root of 8, fractional parts should match
            10             |  -1.533 01(2 798)
          -100             |   2.499 20(3 570)
         1 000             |  -3.977 89(9 393)
      -100 010             |  10.000 0(00 000)      # a = (-10)^5 + (-10)
 1 073 741 888             | -64.000 0(00 000)      # a = 64^5 + 64

Gewinnkriterien

Die kürzeste gültige Einsendung in jeder Sprache gewinnt.

code-golf number polynomials

— Shieru Asakoto
quelle

Antworten:

12

Wolfram Language (Mathematica) , 20 Byte

Root[xx^5+x+#,1]&

Probieren Sie es online!

Immer noch eingebaut, aber zumindest nicht UltraRadical.

(Das Zeichen wird wie |->in Mathematica angezeigt , ähnlich wie =>in JS)

— user202729
quelle

9

Ich frage mich immer wieder, warum Mathematica und anstelle von ↦und verwendetᵀ

— Adám

2

@ Adám soll ich nur Quadrate für die ersten beiden sehen, oder vermisse ich eine Art Schrift ...

— mbrig

6

@mbrig Nur Quadrate. Das ist mein Punkt. Mathematica verwendet Zeichen in den Bereichen für den privaten Gebrauch , obwohl Unicode über die meisten davon verfügt.

— Adám

8

Python 3.8 (Vorabversion) , 60 Byte

f=lambda n,x=0:x!=(a:=x-(x**5+x+n)/(5*x**4+1))and f(n,a)or a

Probieren Sie es online!

Newton-Iterationsmethode. $x' = x - \frac {f(x)} {f'(x)} = x - \frac {x^5+x+n} {5x^4+1}$

Bei Verwendung von $\frac {4x^5-n} {5x^4+1}$ ist mathematisch äquivalent, es macht die Programmschleife für immer.

Anderer Ansatz:

Python 3.8 (Vorabversion) , 102 Byte

lambda x:a(x,-x*x-1,x*x+1)
a=lambda x,l,r:r<l+1e-9and l or(m:=(l+r)/2)**5+m+x>0and a(x,l,m)or a(x,m,r)

Probieren Sie es online!

Binäre Suche, da die Funktion x^5+x+azunimmt. Setzen Sie die Grenzen auf -abs(x)und abs(x)ist ausreichend, aber -x*x-1und x*x+1ist kürzer.

BTW Pythons Rekursionslimit ist etwas zu niedrig, daher ist 1e-9 erforderlich, und der :=wird als Walrossoperator bezeichnet.

— user202729
quelle

Würde eine lineare Suche weniger Bytes benötigen?

— user202729

8

JavaScript (ES7), 44 Byte

Eine sicherere Version mit der gleichen Formel wie unten, jedoch mit einer festen Anzahl von Iterationen.

n=>(i=1e3,g=x=>i--?g(.8*x-n/(5*x**4+5)):x)``

Probieren Sie es online!

JavaScript (ES7), 43 42 Bytes

Newtonsche Methode unter Verwendung von $5x^4+5$ als Approximation von $f'(x)=5x^4+1$ .

n=>(g=x=>x-(x-=(x+n/(x**4+1))/5)?g(x):x)``

Probieren Sie es online!

Wie?

Wir beginnen mit $x_0=0$ und berechnen rekursiv:

x_{k + 1} = x_{k} - \frac{{x_{k}}^{5} + x_{k} + n}{5 {x_{k}}^{4} + 5} = x_{k} - \frac{x_{k} + \frac{n}{{x_{k}}^{4} + 1}}{5}

$x_{k+1}=x_k-\frac{{x_k}^5+x_k+n}{5{x_k}^4+5}=x_k-\frac{x_k+\frac{n}{{x_k}^4+1}}{5}$

bis $x_k-x_{k+1}$ ist unbedeutend.

— Arnauld
quelle

Da der Vergleich der Äquivalenz von Gleitkommazahlen ungenau ist, bin ich mir nicht sicher, ob das Beenden des Programms für jede mögliche Eingabe garantiert werden kann (die Antwort in Python 3 unten zeigt bereits Probleme beim Versuch, die Formel zu verkürzen).

— Joel

1

@ Joel Ich habe eine sicherere Version hinzugefügt.

— Arnauld

7

Gelee , 8 Bytes

;17B¤ÆrḢ

Probieren Sie es online!

Wie es funktioniert:

[a, 1, 0, 0, 0, 1]Erstellt die Liste, indem ader binären Darstellung von vorangestellt wird 17. Warum diese Liste? Weil es den Koeffizienten entspricht, die wir suchen:
```
[a, 1, 0, 0, 0, 1] -> P(x) := a + 1*x^1 + 0*x^2 + 0*x^3 + 0*x^4 + 1*x^5 = a + x + x^5
```
Dann Ærist ein eingebautes, das die Polynomgleichung löst P(x) = 0, gegeben eine Liste der Koeffizienten (was wir vorher konstruiert haben).
Wir interessieren uns nur für die reale Lösung, deshalb nehmen wir den ersten Eintrag in der Liste der Lösungen mit Ḣ.

— Mr. Xcoder
quelle

6

APL (Dyalog Unicode) , 11 10 Bytes ^SBCS

-1 danke an dzaima

Anonyme implizite Präfixfunktion.

(--*∘5)⍣¯1

Probieren Sie es online!

(… )⍣¯1 Wenden Sie einmal die folgende implizite Funktion negativ an:

- das negierte Argument

- Minus

*∘5 das Argument zur Potenz von 5 erhoben

Im Wesentlichen fragt dies: Welches $x$ muss ich $f(x)=-x-x^5$ so zuführen, dass das Ergebnis wird $y$

— Adam
quelle

Das ist sehr cool. Leider scheint J diese Inversion nicht ausführen zu können

— Jonah

@dzaima Warum habe ich das nicht gesehen? Danke.

— Am

5

R , 43 Bytes

function(a)nlm(function(x)abs(x^5+x+a),a)$e

Probieren Sie es online!

nlm $x\mapsto |x^5+x+a|$ nlma

— Robin Ryder
quelle

@TheSimpliFire Mathematisch ist es äquivalent, numerisch jedoch nicht: Die Verwendung des Quadrats anstelle des Absolutwerts führt zu einem falschen Wert für große Eingaben. ( Versuchen Sie es online. )

— Robin Ryder

4

R , 56 Bytes

function(x)(y=polyroot(c(x,1,0,0,0,1)))[abs(Im(y))<1e-9]

Probieren Sie es online!

polyroot $a$ polyroot

— Nick Kennedy
quelle

2

43 Bytes

— Robin Ryder

@RobinRyder das ist ausreichend anders, ich denke du solltest deine eigene Antwort posten. Trotzdem danke!

— Nick Kennedy

1

OK danke. Hier ist es .

— Robin Ryder

"Leider" polyrootgibt alle komplexen Wurzeln zurück ... Sonst würde es gewinnen.

— Roland,

3

J , 14 Bytes

{:@;@p.@,#:@17

Probieren Sie es online!

J hat eine eingebaute für die Lösung von Polynomen ... p.

Die letzten 4 Testfälle haben eine Zeitüberschreitung bei TIO, sind aber theoretisch immer noch korrekt.

Wie

Die Polynomkoeffizienten für Js Builtin werden als numerische Liste mit dem Koeffizienten für x^0first verwendet. Das heißt, die Liste ist:

a 1 0 0 0 1

1 0 0 0 1ist 17 in binär, also stellen wir es so dar #:@17, fügen dann die Eingabe hinzu ,, wenden p.dann an, entpacken die Ergebnisse mit raze ;und nehmen dann das letzte Element{:

— Jona
quelle

3

Ruby , 53 41 Bytes

->a{x=a/=5;99.times{x-=a/(x**4+1)+x/5};x}

Probieren Sie es online!

Verwendung von Newton-Raphson mit einer festen Anzahl von Iterationen und demselben Approximationstrick wie Arnauld

— GB
quelle

2

Pari / GP , 34 32 26 24 Bytes

a->-solve(X=0,a,a-X-X^5)

Probieren Sie es online!

— TheSimpliFire
quelle

Nizza Antwort, aber aus Neugier: warum tut s(-100010)Ergebnis in -8.090... - 5.877...*Ianstatt nur 10? Ist dies eine Einschränkung der Sprache für große Testfälle? PS: Sie können 2 Bytes speichern, indem Sie beide 0.2in ändern .2. :)

— Kevin Cruijssen

R^{-}

$\Bbb R^-$

Sie können eine anonyme Funktion verwenden: a->solve(X=-a,a,X^5+X+a).

— Alephalpha

Danke @alephalpha.

— TheSimpliFire

2

05AB1E , 12 Bytes

ΔyIy4m>/+5/-

Probieren Sie es online!

Newtons Methode.

— Grimmig
quelle

2

k4, 33 31 Bytes

{{y-(x+y+*/5#y)%5+5*/4#y}[x]/x}

Newton-Raphson wird iterativ berechnet, bis eine Zahl konvergiert

edit: -2 danke an ngn!

Hoppla, alles falsch gemacht ...

K (oK), 10 Bytes

{-x+*/5#x}

— kritzeln
quelle

@ngn lol, das war nachlässig ... aktualisiert, aber jetzt in k4, da ich zu faul bin, es in ngn / k oder oK zu tun :)

— Scrawl

cool! das letzte Paar [ ]scheint unnötig

— ngn

hmm, du hast recht. Ich habe schon einmal seltsames Verhalten erlebt, bei dem Über / Konvergieren zu einer Endlosschleife führt, weil (ich vergesse, das eine oder andere) überflüssige / ausgelassene Klammern verwendet werden. Deshalb habe ich sie hier gelassen, aber ich hätte es überprüfen sollen. Vielen Dank!

— Scrawl

1

Pari / GP , 24 Bytes

a->polrootsreal(x^5+x+a)

Probieren Sie es online!

— Alephalpha
quelle

Schön, wusste nicht, dass solvees ein Analogon gibt

— TheSimpliFire

1

C 118b / 96b

#include<math.h>
double ur(double a){double x=a,t=1;while(fabs(t)>1e-6){t=x*x*x*x;t=(x*t+x+a)/(5*t+1);x-=t;}return x;}

118 Bytes mit dem ursprünglichen Funktionsnamen und einer gewissen zusätzlichen Genauigkeit (doppelt). Mit Bit-Hacks ist es vielleicht besser, aber nicht portierbar.

96 Bytes mit festen Iterationen.

double ur(double a){double x=a,t;for(int k=0;k<99;k++){t=x*x*x*x;x=(4*x*t-a)/(5*t+1);}return x;}

Tatsächlich ist unsere Funktion so gut, dass wir die Newtonsche Methode besser anpassen können. Eine viel schnellere und praktischere Implementierung (150 Bytes) wäre

#include<math.h>
double ur(double a){double x=a/5,f=1,t;while(fabs(f)>1e-6){t=x*x*x*x;f=(t*(5*t*x+5*a+6*x)+a+x)/(15*t*t-10*a*x*x*x+1);x-=f;}return x;}

Ich habe überprüft, ob es funktioniert, aber ich bin zu faul, um herauszufinden, wie viel schneller es sein würde. Sollte mindestens eine weitere Bestellung schneller sein als Newtons.

— Sanaris
quelle

Möchten Sie etwas x-=t=...arbeiten?

— user202729

1

82 Bytes

— Ceilingcat

0

Sauber , 61 60 Bytes

import StdEnv
$a=iter 99(\x=(3.0*x^5.0-a)/inc(4.0*x^4.0))0.0

Probieren Sie es online!

Newtons Methode, die zuerst in der Antwort von user202729 implementiert wurde .

Sauber , 124 Bytes

import StdEnv
$a= ?a(~a)with@x=abs(x^5.0+x+a);?u v|u-d==u=u|v+d==v=v= ?(u+if(@u< @v)0.0d)(v-if(@u> @v)0.0d)where d=(v-u)/3E1

Probieren Sie es online!

Eine "binäre" Suche, bei der der Suchbereich bei jeder Iteration auf die oberen oder unteren 99,6% des Bereichs zwischen den oberen und unteren Grenzen anstatt auf 50% eingeschränkt wird.

— Οurous
quelle

0

Python 3 + Sympy, 72 Bytes

lambda y:float(sympy.poly("x**5+x+"+str(y)).all_roots()[0])
import sympy

Probieren Sie es online!

— Nick Kennedy
quelle

0

Oktave , 25 Bytes

@(a)fzero(@(x)x^5+x+a,-a)

Probieren Sie es online!

— tsh
quelle

0

Maplesoft Maple , 23 Bytes

f:=a->fsolve(x^5+x+a=0)

Leider gibt es keinen Online-Maple-Compiler / Taschenrechner von AFAIK. Aber der Code ist ziemlich einfach.

— Polfosol ఠ_ఠ
quelle

Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.

Licensed under cc by-sa 3.0 with attribution required.