Ungefähre Kunststoffnummer


24

Die Herausforderung

Die plastische Zahl ist eine Zahl im Zusammenhang mit dem Goldenen Schnitt mit vielen interessanten mathematischen Eigenschaften. Daher gibt es viele Ansätze, mit denen die Anzahl berechnet werden kann.

Um die Nummer für die Zwecke dieser Herausforderung genau anzugeben, verwenden wir die folgende Definition (obwohl es viele gleichwertige Definitionen gibt und Sie jede beliebige Definition verwenden können, solange es sich um dieselbe Nummer handelt):

Die plastische Zahl ist eine reelle Zahl ρ, so dass ρ ³ = ρ +1 ist.

Ihre Herausforderung besteht darin, ein Programm oder eine Funktion zu schreiben, die eine Ganzzahl x als Eingabe (mit x > 1) verwendet und eine Annäherung an ρ als Ausgabe erzeugt. Je größer der Wert von x, desto näher kommt die Ausgabe an ρ ( mit höchstens endlich vielen Ausnahmen, wobei der gleiche Wert für diesen Zweck als "näher" gilt), und für jede positive Zahl δ gibt es eine Eingabe x in Ihrem Programm, die eine Ausgabe erzeugt, die innerhalb von δ von ρ liegt .

Klarstellungen

  • Wenn Sie über eine Methode ausgeben, die von Natur aus Zeichenfolgen ausgibt (z. B. den Standardausgabestream), können Sie die Ausgabe entweder als Dezimalzahl (z. B. 1.3247179572) oder als Verhältnis von zwei Ganzzahlen mit einem /Zeichen dazwischen formatieren .
  • Wenn Sie in Ihrer Programmiersprache einen Wert ausgeben (z. B. von einer Funktion zurückkehren), muss dieser vom Typ Festkomma, Gleitkomma oder Rational sein. (Insbesondere können Sie keine Datentypen verwenden, in denen Zahlen symbolisch gespeichert werden, es sei denn, sie dienen nur zum Speichern des Verhältnisses zweier Ganzzahlen. Wenn Sie also Mathematica oder eine ähnliche Sprache verwenden, müssen Sie die zusätzlichen Zahlen einschließen Code, um die Ziffern der Ausgabe zu generieren.)
  • Ihre Antwort muss in einer hypothetischen Variante Ihrer Sprache funktionieren, in der ganze Zahlen beliebig groß sein können und der Speicher (einschließlich Stapel) unbegrenzt ist. Sie können nicht davon ausgehen, dass die Gleitkomma-Arithmetik in Ihrer Sprache willkürlich genau ist, sondern müssen stattdessen ihre tatsächliche Genauigkeit verwenden (was bedeutet, dass die Ausgabe einer Gleitkommazahl nur in Sprachen möglich ist, in denen die Genauigkeit von Gleitkommazahlen möglich ist) zur Laufzeit gesteuert).
  • x kann eine beliebige Bedeutung haben (solange die Erhöhung die Ausgabe genauer macht). Ich stelle mir vor, dass bei den meisten Einsendungen die Anzahl der zu erzeugenden Stellen der Ausgabe oder die Anzahl der Iterationen des von Ihrem Programm verwendeten Algorithmus zur Konvergenz der plastischen Zahl gesteuert wird. Andere Bedeutungen sind jedoch akzeptabel.

Testfall

Hier sind die ersten Ziffern der Kunststoffnummer:

1.32471795724474602596090885

Weitere Ziffern sind auf OEIS verfügbar .

Siegbedingung

Wie für , ist kürzer besser, gemessen in Bytes. Sie können jedoch auch dann Antworten veröffentlichen, wenn Sie nicht gewinnen, sofern Sie den vorhandenen Antworten etwas hinzufügen (z. B. eine andere Sprache oder einen anderen Algorithmus).


1
hmm, (cbrt (108 + 12 * sqrt (69)) + cbrt (108-12 * sqrt (69))) / 6 Dies scheint ein guter Zeitpunkt zu sein, um die Drake-Approximation zu verwenden: sqrt (69) = 8. etwas bit.ly/2rCqedX ^ _ ^
DrQuarius

2
Können wir auch davon ausgehen, dass die Rekursion / Stapeltiefe unbegrenzt ist?
16.

Können wir zur Verdeutlichung des zweiten Punktes beliebige Präzisionsbibliotheken verwenden (z. B. mpmath in Python)? Sie verwenden einen Hilfsdatentyp, aber zählen Sie das als "symbolisches" Speichern?
Batman

1
Nun, zumindest würde ich erwarten, dass die Antworten zu ρ konvergieren . Auch eine "ehrliche" Lösung könnte den Test x> y -> | ρx - ρ | leicht nicht bestehen > | ρy - ρ | für eine endliche Anzahl von (x, y) Paaren. Wenn das nicht akzeptabel ist, sollte dies meiner Meinung nach in der Spezifikation expliziter formuliert werden.
Dennis

6
Viele Antwortende sind in die Falle gegangen (?), Eine x-stellige Annäherung an ρ zu berechnen, wobei das Problem darin besteht, dass es wahrscheinlich unendlich viele x gibt, so dass eine (x + 1) -stellige Annäherung nicht besser ist als eine x-stellige Annäherung. Sie sollten wahrscheinlich klarstellen, ob dies zulässig sein soll. Wenn Sie dies nicht tun, ersetzen Sie "näher" durch "genau näher". wenn du das tust, "mindestens so nah" oder so. Sie können auch die lockerere Anforderung berücksichtigen, dass die Sequenz gegen ρ konvergiert , was zusätzlich die Antwort von xnor zulässt.
Anders Kaseorg

Antworten:


10

Python 2 , 49 Bytes

n=x=input()
while n**3/x/x<n+x:n+=1
print n,'/',x

Probieren Sie es online!

Die Idee ist, das ρmit ρ³=ρ+1als Bruch auszudrücken, n/xdessen Nenner xder Eingabegenauigkeitsparameter ist. Wir nehmen (n/x)³=n/x+1und klären Nenner, um zu bekommen n³=x²(x+n).

Da die LHS nschneller ansteigt als die RHS, können wir den Gleichheitspunkt nals kleinsten mit approximieren n³≥x²(x+n). Der Code zählt, nbis dies der Fall ist, beginnend mit xdem kleineren.

Eine kleine Bytespeicherung besteht darin, beide Seiten durch Schreiben zu teilen n³/x²≥x+n(in der whileBedingung negiert ). Dies ist eine Unterteilung des Bodens im Code, aber der Bruchteil des Verlusts ist vernachlässigbar.

Eine Alternative gleicher Länge lautet stattdessen xwie der Zähler:

Python 2 , 49 Bytes

n=x=input()
while x**3/n/n<n+x:n-=1
print x,'/',n

Probieren Sie es online!


Obwohl diese Ausgabe gegen ρ konvergiert (∀ε> 0 ∃x∃ ∀x ≥ x₀ | f (x) - ρ | <ε), erfüllt sie nicht „je größer der Wert von x wird, desto näher kommt die Ausgabe an ρ heran (mit höchstens endlich vielen Ausnahmen) ”(∃x∃ ∀x ≥ x₀ | f (x + 1) - ρ | <| f (x) - ρ |).
Anders Kaseorg

Dieses Problem kann durch die Verwendung von 2**input()anstatt nur behoben werden input(). dann ist jede Annäherung mindestens so genau wie die vorhergehende.

10

Mathematica, 20 Bytes

#^3-#-1&~Root~1~N~#&

Die eingebaute RootFunktion von Mathematica liefert die Lösungen für eine Polynomgleichung f[x] == 0.

Erläuterung

#^3-#-1&~Root~1~N~#&
                   &  (* Function *)
#^3-#-1&              (* A pure-function polynomial, x^3-x-1 *)
        ~Root~1       (* Find the first root *)
               ~N~#   (* approximate to (input) digits *)

Beispiel-E / A

In[1]:= f=#^3-#-1&~Root~1~N~#&;
        f[1]

Out[1]= 1.

In[2]:= f[9]

Out[2]= 1.32471796

In[3]:= f[100]

Out[3]= 1.324717957244746025960908854478097340734404056901733364534015050302827851245547594054699347981787280

PS: Funktioniert Root[x^3-x-1,1]~N~#&einwandfrei (obwohl nicht gesagt wird, dass xes sich um eine Variable handelt) bei gleicher Bytezahl.
Greg Martin

@AndersKaseorg: Ich habe diese Regel geändert, weil sie eindeutig gebrochen war. Es wurden keine gültigen Antworten für ungültig erklärt, aber einige Antworten (wie diese) wurden gültig.

6

Mathematica, 27 Bytes

x/.Solve[x^3==x+1>2,x]~N~#&

-1 Byte von Martin
-2 Byte von Ovs

Eingang

[27]

Ausgabe

{1.32471795724474602596090885}


Solve[x^3==x+1>2,x]~N~#&für 24 Bytes
Ovs

1
Das Ergebnis davon ist {{x -> 1.32...}}jedoch. Vielleicht möchten Sie mit ais prüfen, ob dies ein gültiges Ausgabeformat ist.
Martin Ender

ok .. alles behoben, denke ich
J42161217

Es ist immer noch {1.32...}aktuell, aber dieses Format ist wahrscheinlich weniger umstritten.
Martin Ender

1
Ich habe die Herausforderung etwas allgemeiner gestaltet, damit dies gültig ist. Es war nicht beabsichtigt, Lösungen mit "ersten x Ziffern" zu verbieten. Das ist jetzt gültig, obwohl es vorher nicht war.

6

sed , 67 60 (59 + 1) Bytes

s,^,1/1/1 ,
:;s,(1*/(1*)/(1*).*)1$,\2\3/\1,
t
s,(/1*).*,\1,

Probieren Sie es online!

+1 für das -EFlag (ERE anstelle von BRE). Eingabe und Ausgabe sind beide unär: Eingabe 11111 für x = 5, z. B. Ausgabe ist ein Bruchteil zweier unärer Zahlen: Die oben erwähnte Eingabe 11111 ergibt Ausgabe 11111/1111 (5/4 in Dezimal).

Approximiert die plastische Zahl als Bruch zwischen aufeinanderfolgenden Elementen der Padovan-Sequenz .


1
FWIW Sie brauchen nach dem bBefehl kein Leerzeichen , können es aber noch kürzer machen, indem Sie das leere Label ( :und bohne Argument) verwenden. tio.run/#%23K05N@f@/…
Jordan

Oh, ausgezeichnet. Und ich kann noch 4 Bytes einsparen, indem ich tstattdessen verwende b, also ist das ein ziemlich netter Speichervorgang. Danke :)
FireFly

5

Mathematica, 27 Bytes

Nest[(1+#)^(1/3)&,1,#]~N~#&

Verwendet eine abgeschnittene Approximation der verschachtelten kubischen Radikalform ³√ (1 + ³√ (1 + ³√ (1 + ...)) . Während die Ausgabe immer x-1 Dezimalstellen hat, ist das Ergebnis tatsächlich ungenauer, da der Ausdruck langsamer als eine Ziffer pro Iteration konvergiert ( x wird auch als Anzahl der verschachtelten Radikale verwendet, die berechnet werden). Zum Beispiel ergibt x = 100

_________________________________________________________________________
1.324717957244746025960908854478097340734404056901733364534015050302827850993693624204577670741656151

wo der überstrichene Teil richtig ist.


Ich hatte vor, diesen Algorithmus in zu schreiben dc, wurde aber geschwächt, weil sich herausstellte, dass es keine Kubikwurzeloperation gibt, und eine Zahl hochzuschalten Mathematica, um entsprechende Builtins zu haben ...

3
@ ais523 Eigentlich gibt CubeRootes dafür aber niemanden, der Bytes hat.
Martin Ender

4

Oktave , 50 Bytes

@(n)char(digits(n)*0+vpasolve(sym('r^3-r-1'))(1));

Probieren Sie es online!

Definiert eine anonyme Funktion mit nder gewünschten Anzahl von Ausgabestellen.

Diese Antwort digitsgibt die aktuelle Einstellung für die Anzahl der Stellen in arithmetischer Form mit variabler Genauigkeit zurück. Dies bedeutet, dass wir es nur in einer anonymen Funktion verwenden können, ohne dass Fehler bei "Zu vielen Ausgabeargumenten" auftreten.

vpasolveDavon abgesehen ist es ganz einfach: steht für Variable-Precision Arithmetic Solve (Arithmetisches Lösen mit variabler Genauigkeit), mit der Präzision, die beim letzten Aufruf von festgelegt wurde digits. Da vpaes sich bei Octave um einen symbolischen Datentyp handelt, der gemäß Spezifikation gesperrt ist, wird nur die gesamte Funktion eingebunden char(...), um die Zeichenfolgenausgabe zu erhalten. Beachten Sie, dass in solveund vpasolvedas f==0impliziert ist, also r^3==r+1durch ersetzt wurder^3-r-1 (==0)


Ich habe die Frage geändert, damit solche Antworten nicht unzulässig sind (das war nicht beabsichtigt).

@ ais523 Danke für die Benachrichtigung!
Sanchises

4

MATL ( 27 - 28 Byte)

7BG:"t@)y@Q)+h]tG3+)yG2+)/

Meine erste Lösung (27 Bytes)

Probieren Sie es online!

Es ist sicherlich nicht optimal, ich gewöhne mich immer noch an MATL.

Erläuterung:

Ich erstelle eine Padovan-Sequenz bis zu Eingabe + 3 und finde dann das Verhältnis der letzten beiden Zahlen.

7B     % Turn 7 into binary to give 1 1 1 
G:"    % For k=1:input do...
t@)    % Existing sequence member k
y@1+)  % Existing sequence member k+1
+h     % Add them together and concatenate to the sequence array
]      % End loop
tG3+)  % Final sequence member
yG2+)  % Second last sequence member
/      % Divide to approximate ρ

Richtige Bruchausgabe (35 Bytes) (28 Bytes, @Sanchises):

Die erste Lösung erfüllt jedoch nicht die Forderung nach willkürlicher Genauigkeit als Gleitkomma-Grenze der Standard-MATL-Einstellungen. Anstatt mehrere Bytes hinzuzufügen, um diese Genauigkeit zu erhöhen, ist es einfacher, den richtigen Bruchweg einzuschlagen und einen Bruch der letzten beiden Ganzzahlen in das (N-1) -te und das N- te Element der abgeschnittenen Padovan-Folge zu schreiben .

zB "114/86"

7BG: t @) y @ 1 +) + h] tG3 +) V '/' YcyG2 +) VYc

7BG:"t@tQh)sh]tJ)V47hyJq)Vh&

Mit freundlicher Genehmigung von User @Sanchises. :)

Probieren Sie es online!

Nicht iterative Auswertung:

Mein kürzester Code für die 'genaue' Version ist (23 Bytes):

1-1h69X^12**108+1I/^6/s

Probieren Sie es online!

... gibt aber keine willkürliche Genauigkeit. Ich frage mich, ob jemand dies anpassen kann, um die Regeln zu erfüllen (verwenden Sie die Eingabe usw.) und trotzdem weniger als 5 Bytes hinzufügen kann? : P


1
1+kann auf verkürzt werden. In QAnbetracht dessen können Sie @)y@1+)+mit nur ersetzen @tQh)s. Darüber hinaus können Sie Jmit das Ende eines Arrays angeben. und schließlich ist MATL nicht zwischen normalen Arrays und Zeichenfeldern unterscheiden, so dass Sie ersetzen können Ycdurch h(Sie brauchen nicht die zusätzliche Funktionalität Yc). Dies ergibt nur 28 Bytes: 7BG:"t@tQh)sh]tJ)V47hyJq)Vh&(Beachten Sie das &, um überflüssige Ausgaben zu vermeiden und '/'durch 47 zu ersetzen ).
Sanchises

1
Ein 7Blllv
dickes Lob

1
@ DrQuarius Die neueste Version ist immer in diesem GitHub-Link zu finden
Luis Mendo

1
@DrQuarius Nein, dieses Verhalten ist in der ziemlich alten MATL-Spezifikation vorhanden, die ich normalerweise verwende. Sie sollten überprüfen Tabelle wirklich 3. Nicht nur , dass die Zwischenablage Jstandardmäßig enthalten 1j, aber die Zwischenablage Lenthält auch viele nützliche Indexierungsfunktionen (Note , die 1jgleich endin MATL).
Sanchises

1
Keine Sorge, ich bin Maschinenbauingenieur. Ich denke, MATL (AB) hat außerhalb eines wissenschaftlichen Umfelds wenig Verwendung, daher würde ich vermuten, dass die Mehrheit der MATL (AB) / Octave-Golfer von außerhalb von CS stammt.
Sanchises

4

M , 15 14 Bytes

²×3’
*3Ḥ‘÷Ç
Ç¡

Probieren Sie es online!

Algorithmus

Dies verwendet Rationals und Newtons Methode. Insbesondere werden für die Eingabe x die ersten x- Iterationen mit dem Startwert x angewendet.

Wir versuchen, eine bestimmte Wurzel des Polynoms p (t) = t³ - t - 1 zu finden . Newtons Methode erreicht dies, indem sie einen Startwert t 0 - ausreichend nahe bei ρ - annimmt und eine Folge rekursiv durch
t n + 1 = t n - p (t n ) / p '(t n ) definiert. .

Da p '(t) = 3t² -1 erhalten wir
t n + 1 = t n - (t n ³ - t n - 1) / (3t n ² - 1) = (3t n ³ - t n - t n ³ + t n + 1) / (3T n ² - 1) = (2t n ³ + 1) / (3T n ² - 1) .

Beachten Sie, dass die anfängliche Annäherung x zunehmend schlechter als bekommt x zunimmt. Während die Ausgabe für x = 3 etwas ungenauer ist als die Ausgabe für x = 2 , sollte dies für große Werte von x kein Problem sein , da Newtons Methode quadratisch zu ρ konvergiert .

Wie es funktioniert

Ç¡    Main link. Argument: x

Ç¡    Call the second helper link x times, which initial argument x.


*3Ḥ‘÷Ç  Second helper link. Argument: t

*3      Compute t³.
  Ḥ     Unhalve; yield 2t³.
   ‘    Increment; yield 2t³+1.
     Ç  Call the first helper link with argument t.
    ÷   Divide the left result by the right one.


²×3’    First helper link. Argument: t

²       Compute t².
 ×3     Compute 3t².
   ’    Decrement; yield 3t²-1.

Schade, dass Sie nicht verwenden können ... µ¡...
Erik der Outgolfer



1

Kohle , 28 Bytes

AIθθAθνW‹∕∕Xν³θθ⁺νθA⁺ν¹νI∕νθ

Probieren Sie es online! Link zum ausführlichen Modus. Auch habe ich anscheinend versaut Divideund IntDivide: |
Verwendet die gleiche Methode wie die Antworten in Python und JavaScript.


1

NewStack , 14 Bytes

¹Fᵢ{E2x³⁺÷3x²⁻

Nervenzusammenbruch:

¹                Add arbitrary number 1 to the stack.
 Fᵢ{             Define for loop with a user's input amount of itterations.
    E            Define new edit for element 0 (element 0 being the 1 added. earlier).
     2x³⁺÷3x²⁻   update x to equal (2x^3+1)/(3x^2-1). (x = element 0).

Wie es funktioniert:

Die Formel (2x 3 +1) / (3x 2 -1) ergibt sich aus der Vereinfachung der Newtonschen Methode für die Gleichung x 3 = x + 1. Sie finden es hier . Diesen Vorgang unendlich oft zu wiederholen, konvergiert gegen die plastische Zahl. Die Konvergenzrate ist mit etwa 2,6 Dezimalstellen pro Iteration ziemlich schnell.

INPUT ITERATION >> VALUE
0 >> 1
1 >> 1.5
2 >> 1.3478260869565217
3 >> 1.325200398950907
4 >> 1.3247181739990537
5 >> 1.3247179572447898
6 >> 1.324717957244746    <- 16 decimal precision in 6 iterations!
...
100 >> 1.324717957244746

Padovan-Sequenzalternative, 27 25 17 Bytes

¹Fᵢ{[ƨ2+ƨ3]ℲƤƨ/ƨ2

Nervenzusammenbruch:

¹                  Append first element of Padovan sequence.
 Fᵢ{       Ⅎ       Define for loop of user's input amount of iterations.
    [ƨ2+ƨ3]        Append sum second and third to last elements.
            Ƥƨ/ƨ2  Print ratio of last two elements.

-2 Bytes durch Auswahl einer besseren Druckstrategie

-8 Bytes durch Auswahl einer besseren Methode zum Indizieren des Stapels

Wie es funktioniert:

Während die Padovan-Sequenz fortgesetzt wird, konvergiert das Verhältnis der letzten beiden Elemente zur plastischen Zahl.

INPUT ITERATION >> VALUE
0 >> 1
1 >> 2
...
10 >> 1.3157894736842106
...
89 >> 1.324717957244746    <- 16 decimal precision in 89 iterations
...
100> > 1.324717957244746

0

Clojure, 46 Bytes

#(nth(iterate(fn[i](Math/pow(inc i)(/ 3)))1)%)

Verwendet die iterierte Kubikwurzelformel. Das ist etwas interessanter, aber länger:

(def f #(apply comp(repeat %(fn[i](Math/pow(inc i)(/ 3))))))

((f 10)1)
1.3247179361449652

„Sie dürfen nicht davon ausgehen, dass Gleitkomma-Arithmetik in Ihrer Sprache willkürlich genau ist, sondern müssen ihre tatsächliche Genauigkeit verwenden (was bedeutet, dass die Ausgabe einer Gleitkommazahl nur in Sprachen möglich ist, in denen die Genauigkeit von Gleitkommazahlen möglich ist zur Laufzeit gesteuert werden).
Anders Kaseorg

Oh, das habe ich nicht bemerkt, was für ein Mist. Und Kubikwurzel mit BigDecimal zu implementieren, scheint ziemlich schwierig.
NikoNyrh

0

Javascript, 36 Bytes

f=(x,n=x)=>n**3/x/x<n+x?f(x,++n):n/x

Funktioniert genauso wie die oberste Python-Antwort. Nein, console.logda beim Ausführen f(x)in der Konsole diese automatisch protokolliert wird.

f=(x,n=x)=>n**3/x/x<n+x?f(x,++n):n/x
console.log(f(300))


0

> <> , 38 + 3 = 41 Bytes

11\n;
?!\}2,:01{::::}**-+0(?$-{+{1-:}

Erwartet, dass die Eingabe beim Programmstart auf dem Stack vorhanden ist, also +3 Byte für das -vFlag.

Probieren Sie es online!

Führt effektiv eine binäre Suche durch, um den Ausgabewert einzugrenzen. Durch xErhöhen wird die Anzahl der durchzuführenden Iterationen erhöht.

Bearbeiten: Berechnung leicht überarbeitet, um 1 Byte zu sparen, Vorgängerversion:

11\n;
?!\}2,:0{::::}**$-1-0)?$-{+{1-:}


0

TI-BASIC, 21 Bytes

:Prompt X //Prompt for input, 3 bytes
:While X  //While X, 3 bytes
:³√(1+Y→Y //Calculate cube root of 1+Y and store to Y, 7 bytes
:DS<(X,0  //Decrement X and skip next command (which doesn't do anything), 5 bytes
:End      //End While loop, 2 bytes
:Y        //Display Y, 1 byte

Verwendet diese rekursive Formel .

Interessanterweise ergibt eine harte Codierung der Zahl und eine Rundung derselben Byteanzahl:

TI-BASIC, 21 Bytes

:Prompt X    //Prompt for input, 3 bytes
:.5√(3       //Store √(3)/2 to Ans, 5 bytes
:Ansֿ¹cosh(3ֿ¹coshֿ¹(3Ans //Store the plastic number to Ans, 9 bytes
:round(Ans,X //Round the plastic number X decimal digits, 4 bytes

Verwendet diese trigonometrische Formel .


Ich glaube nicht, dass Sie hier die Your answer must work in a hypothetical variant of your language in which integers can be arbitrarily large, and memory (including stack) is unlimited. You may not assume that floating-point arithmetic in your language is arbitrarily accurate, but must instead use its actual accuracy (meaning that outputting a floating-point number is only going to be possible in languages where the accuracy of floating-point numbers can be controlled at runtime).
Posen von

0

C # , 317 Bytes

using m=System.Math;a=x=>{if(a==0)return "1/1";var d=a(x-1).Split('/');var b=int.Parse(d[0]);var c=int.Parse(d[1]);return string.Format("{0}/{1}",(2*m.Pow(b,3)+m.Pow(c,3)).ToString(new string('#',int.MaxValue.ToString().Length)),(3*m.Pow(b,2)*c-m.Pow(c,3)).ToString(new string('#',int.MaxValue.ToString().Length)));};

Es gibt das Ergebnis als Bruch zurück.

Erläuterung

Es verwendet die Newtonsche Methode mit x Iterationen, um die Wurzel des Polynoms p ^ 3-p-1 = 0 zu finden. Die Formel lautet x_n = 1- (f (x_ (n-1))) / (f '(x_ (n-1))) und x_0 ist ein Ausgangspunkt.

Die Polynomableitung ist 3p ^ 2-1, und lassen Sie uns x_ (n-1) = b / c sagen. Mit der obigen Formel erhalten wir dann x_n = (2 b ^ 3 + c ^ 3) / (3 b ^ 2 cc ^ 3). Sagen wir auch, dass wir mit 1 beginnen. Dies geschieht, wenn x = 2 ist, weil x> 1 und eine ganze Zahl ist. Identifizierter und kommentierter Code:

using System;
string PlasticNumber(int x)
{
    if (x == 2) 
        return "1/1";                 

//If x=2, we return our starting value, but we need to return it as a fraction

    var d = PlasticNumber(x - 1).Split('/');
    var b = System.Convert.ToInt32(d[0]);
    var c = int.Parse(d[1]);

//We parse the previous value of the fraction, and put it into two variables

    return string.Format("{0}/{1}", 
        (2 * Math.Pow(b, 3) + Math.Pow(c, 3))
        .ToString(new string('#', int.MaxValue.ToString().Length)),
        (3 * Math.Pow(b, 2) * c - Math.Pow(c, 3))
        .ToString(new string('#', int.MaxValue.ToString().Length)));

//We return the result as a fraction, but it's important not to return it in
  scientific notation, because that will cause issues in the parsing process 

}


0

Axiom 96 Bytes

h(n:NNI):Float==(n>1.E5=>-1;n:=n+1;j:=digits(n::PI);r:=solve(x^3-x=1,10.^-n);digits(j);rhs(r.1))

Ergebnisse

(31) -> [h(i) for i in 0..10]
   (31)
   [1.0, 1.3, 1.33, 1.325, 1.3247, 1.32472, 1.324718, 1.324718, 1.32471796,
    1.324717957, 1.3247179572]
                                                         Type: List Float

Wie Sie sehen können, sollte h (2) 1,32 und nicht 1,33 sein, daher liegt ein Fehler in den letzten Ziffern vor

Dann wäre da einer von 110 Bytes

g(n:NNI):Float==(n>1.E5=>-1;n:=n+1;j:=digits(n::PI);x:=sqrt(23./108);r:=(.5+x)^(1/3)+(.5-x)^(1/3);digits(j);r)

Es wird die Formel für die Auflösungsgleichung der Klasse III des Typs x ^ 3-3 * p * x-2 * q = 0 verwendet, wenn q ^ 2-p ^ 3> = 0 ist, dh m = sqrt (q ^ 2- p ^ 3) und x = (q + m) ^ (1/3) + (qm) ^ (1/3)

In unserem Fall r ^ 3-r-1 = 0 kann dies geschrieben werden als r ^ 3-3 * (1/3) r-2 * (1/2) = 0, so dass p = 1/3 q = 1/2 m = 1 / 4-1 / 27 = 23/108 x = (0,5 + m) ^ (1/3) + (0,5-m) ^ (1/3)

Diesmal wird die Newton-Iteration mit dem Startpunkt r = 1 verwendet

f(n:NNI):Float==(n>1.E5=>-1;n:=n+1;j:=digits(n::PI);e:=10^-n;r:=1.;repeat(v:=(r^3-r-1)/(3*r^2-1);abs(v)<e=>break;r:=r-v);digits(j);r)

es ändert sich in der Funktion der Ziffernwert, um ein Objekt von n + 1 Ziffern nach dem Gleitkomma zu erhalten. Am Ende wird der Wert von digits () dem vorhergehenden Wert zugewiesen.


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.