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 Code-Golf üblich , 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).

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 x²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!

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

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}

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 .

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.

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)

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

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 ₀ - 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.

Julia 0,5 ,  44  40 Bytes

|(x,r=1)=x<1?r:~-x|big(2r^3+1)//(3r^2-1)

Verwendet Rationals und Newtons Methode.

Probieren Sie es online!

05AB1E , 23 Bytes

U[X3m¹/¹/¹X+›#X>U]X'/¹J

Probieren Sie es online!

Direkter Port von /codegolf//a/126822/59376 von xnor.

Kohle , 28 Bytes

ＡＩθθＡθνＷ‹∕∕Ｘν³θθ⁺νθＡ⁺ν¹νＩ∕νθ

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.

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 ³ +1) / (3x ² -1) ergibt sich aus der Vereinfachung der Newtonschen Methode für die Gleichung x ³ = 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

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

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

> <> , 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-:}

k, 27 Bytes

{"/"/$1_|x({y,z,x+y}.)/3#1}

Probieren Sie es online! Dies setzt unendliche ganze Zahlen voraus (was leider nicht wahr ist). Es wird die Padovan-Sequenz verwendet .

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 .

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 

}

PHP, 86 Bytes

for($p=[1,1,1];$i++<$argn;)$p[]=bcadd($p[$i],$p[$i-1]);echo bcdiv($p[$i+1],$p[$i],$i);

PHP Sandbox Online

Erstellt die Padovan-Spirale und druckt das Verhältnis der letzten beiden Zahlen.

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.

Ruby , 35 Bytes

->x{n=1;n+=0.1**x while n**3-n<1;n}

Probieren Sie es online!