ความท้าทาย

จำนวนพลาสติกเป็นจำนวนที่เกี่ยวข้องกับอัตราส่วนทองคำมีหลายคุณสมบัติทางคณิตศาสตร์ที่น่าสนใจ ดังนั้นจึงมีวิธีการมากมายที่สามารถใช้ในการคำนวณจำนวน

เพื่อระบุจำนวนอย่างแม่นยำสำหรับวัตถุประสงค์ของการท้าทายนี้เราจะใช้คำจำกัดความต่อไปนี้ (แม้ว่าจะมีคำจำกัดความที่เทียบเท่ากันมากมายและคุณสามารถใช้คำจำกัดความใด ๆ ที่คุณต้องการตราบใดที่มันเป็นหมายเลขเดียวกัน):

จำนวนพลาสติกเป็นจำนวนจริงρดังกล่าวที่ρ ³ = ρ 1

ความท้าทายของคุณคือการเขียนโปรแกรมหรือฟังก์ชั่นซึ่งใช้จำนวนเต็มxเป็นอินพุต (ด้วยx > 1) และสร้างการประมาณρเป็นเอาท์พุทเช่นยิ่งค่าของxมากขึ้นเท่าไหร่ผลลัพธ์ที่ได้จะใกล้ถึงρ ( ที่มีมากที่สุดในหลายข้อยกเว้นขีด; เข้าพักที่นับค่าเช่นเดียวกับ "ใกล้ชิด" สำหรับวัตถุประสงค์นี้) และสำหรับการใด ๆ จำนวนบวกδมีบางอินพุตxในการเขียนโปรแกรมของคุณที่ก่อให้เกิดผลลัพธ์ที่ภายในδของρ

ชี้แจง

• หากคุณกำลังส่งออกโดยใช้วิธีการที่เอาท์พุทสตริงโดยธรรมชาติ (เช่นกระแสออกมาตรฐาน) คุณสามารถจัดรูปแบบเอาท์พุททั้งในทศนิยม (เช่น1.3247179572) หรือเป็นอัตราส่วนของจำนวนเต็มสอง/ตัวที่มีตัวละครระหว่างพวกเขา
• หากคุณกำลังแสดงผลเป็นค่าในภาษาการเขียนโปรแกรมของคุณ (เช่นกลับมาจากฟังก์ชั่น) มันจะต้องเป็นประเภทจุดคงที่จุดลอยตัวหรือเหตุผล (โดยเฉพาะคุณไม่สามารถใช้ชนิดข้อมูลที่เก็บตัวเลขเป็นสัญลักษณ์ได้เว้นแต่ว่าพวกมันใช้เพื่อเก็บอัตราส่วนของจำนวนเต็มสองตัวเท่านั้นดังนั้นหากคุณใช้ Mathematica หรือภาษาที่คล้ายกันคุณจะต้องรวมส่วนเพิ่มเติม รหัสเพื่อสร้างตัวเลขจริงของการส่งออก)
• คำตอบของคุณจะต้องทำงานในรูปแบบที่แตกต่างของภาษาของคุณซึ่งจำนวนเต็มอาจมีขนาดใหญ่และหน่วยความจำ (รวมถึงสแต็ค) ไม่ จำกัด คุณอาจไม่คิดว่าเลขทศนิยมในภาษาของคุณมีความถูกต้องตามอำเภอใจ แต่ต้องใช้ความถูกต้องจริงแทน (หมายถึงการแสดงผลหมายเลขจุดลอยตัวจะเป็นไปได้เฉพาะในภาษาที่ความแม่นยำของตัวเลขจุดลอยตัวสามารถ ควบคุมที่รันไทม์)
• xสามารถมีความหมายใด ๆ ที่คุณต้องการ (ตราบใดที่การเพิ่มมันให้ผลลัพธ์ที่แม่นยำมากขึ้น) ฉันจินตนาการว่าการส่งส่วนใหญ่จะให้มันควบคุมจำนวนตัวเลขของผลผลิตเพื่อผลิตหรือจำนวนการวนซ้ำของอัลกอริทึมที่โปรแกรมของคุณใช้เพื่อรวมกันกับตัวเลขพลาสติก แต่ความหมายอื่น ๆ เป็นที่ยอมรับได้

TestCase

นี่คือตัวเลขสองสามตัวแรกของหมายเลขพลาสติก:

1.32471795724474602596090885

ตัวเลขอื่น ๆ ที่มีอยู่ใน OEIS

เงื่อนไขชัยชนะ

ตามปกติสำหรับcode-golf ที่สั้นกว่าจะดีกว่าวัดเป็นไบต์ อย่างไรก็ตามอย่าลังเลที่จะโพสต์คำตอบแม้ว่าพวกเขาจะไม่ชนะตราบใดที่พวกเขาเพิ่มบางสิ่ง (เช่นภาษาที่แตกต่างกันหรืออัลกอริทึมที่แตกต่างกัน) ให้กับคำตอบที่มีอยู่

Python 2 , 49 ไบต์

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

ลองออนไลน์!

แนวคิดคือการแสดงρด้วยρ³=ρ+1เป็นเศษส่วนn/xซึ่งตัวส่วนxเป็นพารามิเตอร์ความแม่นยำของอินพุต เราใช้และตัวหารที่ชัดเจนที่จะได้รับ(n/x)³=n/x+1n³=x²(x+n)

ตั้งแต่ LHS เพิ่มขึ้นnเร็วกว่า RHS เราสามารถใกล้เคียงกับจุดที่เสมอภาคเป็นที่เล็กที่สุดที่มีn n³≥x²(x+n)รหัสจะนับnจนถึงกรณีนี้โดยเริ่มจากxที่เล็กกว่า

ไบต์ขนาดเล็กบันทึกคือการแบ่งทั้งสองด้านโดยx²การเขียนn³/x²≥x+n(เมื่อตะกี้ในwhileเงื่อนไข) นี่คือการแบ่งชั้นในรหัส แต่ส่วนเศษส่วนที่หายไปเล็กน้อย

ทางเลือกที่มีความยาวเท่ากันแทนที่จะใส่xเป็นตัวเศษ:

Python 2 , 49 ไบต์

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

ลองออนไลน์!

Mathematica ขนาด 20 ไบต์

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

builtin Mathematica ของฟังก์ชั่นช่วยให้โซลูชั่นเพื่อสมการพหุนามRootf[x] == 0

คำอธิบาย

#^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 *)

ตัวอย่าง I / O

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 ไบต์

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

-1 ไบต์จาก Martin
-2 ไบต์จาก ovs

อินพุต

[27]

เอาท์พุต

{1.32471795724474602596090885}

sed , 67 60 (59 + 1) ไบต์

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

ลองออนไลน์!

+1 สำหรับ-Eธง (ERE แทน BRE) อินพุทและเอาท์พุทเป็นทั้งเอกภาพ: อินพุท 11111 สำหรับ x = 5 เช่นเอาท์พุทเป็นเศษส่วนของสองหมายเลขยูนารี: อินพุต 11111 ดังกล่าวข้างต้นให้ผลผลิตเอาท์พุต 11111/1111 (5/4 เป็นทศนิยม)

ราคาใกล้เคียงจำนวนพลาสติกเป็นส่วนระหว่างองค์ประกอบต่อเนื่องเป็นลำดับ Padovan

Mathematica ขนาด 27 ไบต์

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

ใช้ตัดทอนประมาณของรูปแบบที่รุนแรงซ้อนกันลูกบาศก์³√ (1 + ³√ (1 + ³√ (1 + ... ))) ในขณะที่เอาต์พุตจะมีตำแหน่งทศนิยมx-1เสมอผลลัพธ์ที่ได้นั้นมีความแม่นยำน้อยกว่าเนื่องจากนิพจน์นั้นมาบรรจบกันช้ากว่าหนึ่งหลักต่อหนึ่งการวนซ้ำ ( xยังใช้เป็นจำนวนของอนุมูลที่ซ้อนกันที่คำนวณ) ตัวอย่างเช่นx = 100ให้

_________________________________________________________________________
1.324717957244746025960908854478097340734404056901733364534015050302827850993693624204577670741656151

ส่วนที่ overlined ถูกต้อง

อ็อกเทฟ 50 ไบต์

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

ลองออนไลน์!

กำหนดฟังก์ชั่นที่ไม่ระบุชื่อด้วยnจำนวนหลักของเอาต์พุตที่ต้องการ

คำตอบนี้เป็นการละเมิดที่digitsส่งกลับการตั้งค่าปัจจุบันสำหรับจำนวนหลักในการคำนวณความแม่นยำของตัวแปร ซึ่งหมายความว่าเราสามารถใช้ในฟังก์ชั่นนิรนามโดยไม่มีข้อผิดพลาดเกี่ยวกับ 'อาร์กิวเมนต์เอาต์พุตมากเกินไป'

อื่น ๆ กว่าที่มันตรงไปตรงมาจริงๆ: สั้นสำหรับตัวแปรความแม่นยำทางคณิตศาสตร์การแก้ปัญหาด้วยการตั้งค่าความแม่นยำโดยการโทรล่าสุดของvpasolve digitsเนื่องจากvpaเป็นชนิดข้อมูล Symbolic ในอ็อกเทฟซึ่งถูกแบนตามสเป็คเราเพียงแค่ห่อฟังก์ชันทั้งหมดchar(...)เพื่อรับเอาท์พุทสตริง โปรดทราบว่าในsolveและvpasolve, f==0โดยนัยดังนั้นจึงr^3==r+1ถูกแทนที่ด้วยr^3-r-1 (==0)

MATL ( 27 28 ไบต์)

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

วิธีแก้ปัญหาแรกของฉัน (27 ไบต์)

ลองออนไลน์!

แน่นอนว่ามันไม่เหมาะสมฉันยังคงคุ้นเคยกับ MATL อยู่

คำอธิบาย:

ฉันสร้างลำดับ Padovanขึ้นไปที่อินพุต + 3 แล้วหาอัตราส่วนของตัวเลขสองตัวสุดท้าย

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 ρ

เอาต์พุตเศษส่วนที่เหมาะสม(35 ไบต์) (28 ไบต์, @Sanchises):

อย่างไรก็ตามวิธีแก้ไขปัญหาแรกนั้นไม่ได้ตอบสนองความต้องการด้านความแม่นยำโดยพลการซึ่งเป็นข้อ จำกัด ในการตั้งค่าเริ่มต้นของ MATL ดังนั้นแทนที่จะเพิ่มหลายไบต์เพื่อขยายความแม่นยำนี้มันง่ายกว่าที่จะหาเส้นทางเศษส่วนที่เหมาะสมและเขียนเศษส่วนของจำนวนเต็มสองจำนวนสุดท้ายในองค์ประกอบ (N-1) ^thและ N ^thของลำดับ Padovan ที่ถูกตัดทอน

เช่น "114/86"

7BG: t "@) Y @ 1 +) + h] TG3 +) V '/' YcyG2 +) VYC

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

ความอนุเคราะห์จากผู้ใช้ @Sanchises :)

ลองออนไลน์!

การประเมินที่ไม่ทำซ้ำ:

โดยเฉพาะอย่างยิ่งรหัสสั้นที่สุดของฉันสำหรับรุ่น 'ถูกต้อง'คือ (23 ไบต์):

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

ลองออนไลน์!

... แต่ไม่ได้ให้ความแม่นยำตามอำเภอใจ ฉันสงสัยว่าใครสามารถปรับเปลี่ยนสิ่งนี้เพื่อทำตามกฎ (ใช้อินพุต ฯลฯ ) และยังเพิ่มน้อยกว่า 5 ไบต์ได้ไหม : P

M , 15 14 ไบต์

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

ลองออนไลน์!

ขั้นตอนวิธี

สิ่งนี้ใช้เหตุผลและวิธีของนิวตัน โดยเฉพาะสำหรับการป้อนข้อมูลxครั้งแรกxซ้ำกับการเริ่มต้นค่าxจะนำไปใช้

เรากำลังพยายามที่จะหารากที่เฉพาะเจาะจงของพหุนามP (t) = t³ - ที - 1 วิธีการของนิวตันนี้ประสบความสำเร็จโดยการเริ่มต้นค่าที₀ - พอใกล้กับρ - และซ้ำกำหนดลำดับโดย
ที_{1 + n} t = _n p - (t _n ) / p '(t _n )

ตั้งแต่p '(t) = 3t² -1เราจะได้
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)

โปรดทราบว่าการประมาณเริ่มต้นxแย่ลงเรื่อย ๆ เมื่อxเพิ่มขึ้น ในขณะที่การส่งออกสำหรับx = 3คือน้อยแม่นยำกว่าการส่งออกสำหรับx = 2ตั้งแต่นิวตันวิธีลู่ quadratically เพื่อρนี้ไม่ควรเป็นปัญหาสำหรับค่ามากx

มันทำงานอย่างไร

Ç¡    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 ไบต์

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

ใช้เหตุผลและวิธีการของนิวตัน

ลองออนไลน์!

05AB1E , 23 ไบต์

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

ลองออนไลน์!

พอร์ตโดยตรงของ/codegolf//a/126822/59376โดย xnor

ถ่าน 28 ไบต์

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

ลองออนไลน์! ลิงก์ไปที่โหมด verbose นอกจากนี้ฉันเห็นได้ชัดว่าสับสนDivideและIntDivide: |
ใช้วิธีการเดียวกันกับคำตอบของ Python และ JavaScript

NewStackขนาด 14 ไบต์

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

ทำให้พังถล่ม:

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

มันทำงานอย่างไร:

สูตร (2x ³ +1) / (3x ² -1) มาจากความเรียบง่ายของวิธีการของนิวตันสำหรับ equasion x จำนวน³ = x + 1 คุณสามารถค้นหาได้ที่นี่ การทำซ้ำขั้นตอนนี้เป็นเวลาไม่ จำกัด จำนวนครั้งที่มาบรรจบกับจำนวนพลาสติก อัตราการลู่เข้าค่อนข้างเร็วที่ประมาณ 2.6 ทศนิยมต่อการวนซ้ำ

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 27 25 17 ไบต์

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

ทำให้พังถล่ม:

¹                  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 ไบต์โดยเลือกกลยุทธ์การพิมพ์ที่ดีกว่า

-8 ไบต์โดยเลือกวิธีที่ดีกว่าในการสร้างดัชนีสแต็ก

มันทำงานอย่างไร:

ในขณะที่ลำดับของ Padovanยังคงดำเนินต่อไปอัตราส่วนขององค์ประกอบสองตัวสุดท้ายจะรวมกันเป็นจำนวนพลาสติก

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

Clojure 46 ไบต์

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

ใช้สูตรคิวบ์รูทที่ทำซ้ำ มันน่าสนใจกว่านี้อีกหน่อย

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

((f 10)1)
1.3247179361449652

Javascript, 36 ไบต์

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

ทำงานเช่นเดียวกับคำตอบของหลามชั้นนำ ไม่console.logถูกรวมเพราะถ้าคุณใช้f(x)ในคอนโซลมันจะถูกบันทึกโดยอัตโนมัติ

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

> <> , 38 + 3 = 41 ไบต์

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

คาดว่าอินพุตจะแสดงบนสแต็กเมื่อเริ่มต้นโปรแกรมดังนั้นจึงมีค่า 3 ไบต์สำหรับ-vแฟล็ก

ลองออนไลน์!

ทำการค้นหาแบบไบนารีอย่างมีประสิทธิภาพเพื่อ จำกัด ค่าผลลัพธ์ให้แคบลง การเพิ่มจะxเพิ่มจำนวนการวนซ้ำเพื่อดำเนินการ

แก้ไข: คำนวณการ refactored เล็กน้อยเพื่อบันทึก 1 ไบต์, เวอร์ชันก่อนหน้า:

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

k, 27 ไบต์

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

ลองออนไลน์! นี่ถือว่าเป็นจำนวนเต็มอนันต์ (ซึ่งอนิจจาไม่จริง) มันใช้ลำดับ Padovan

TI-BASIC ขนาด 21 ไบต์

: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

นี้ใช้สูตร recursive

สิ่งที่น่าสนใจคือการเข้ารหัสตัวเลขและการปัดเศษจะให้นับไบต์เดียวกัน:

TI-BASIC ขนาด 21 ไบต์

: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

ใช้สูตรตรีโกณมิตินี้

C # , 317 ไบต์

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

ส่งคืนผลลัพธ์เป็นเศษส่วน

คำอธิบาย

มันใช้วิธีของนิวตันด้วยการวนซ้ำ x เพื่อค้นหารากของพหุนาม p ^ 3-p-1 = 0 สูตรคือ x_n = 1- (f (x_ (n-1))) / (f '(x_ (n-1)))) และ x_0 เป็นจุดเริ่มต้น

อนุพันธ์พหุนามมี 3p ^ 2-1 และสมมุติว่า x_ (n-1) = b / c จากนั้นโดยใช้สูตรข้างต้นที่เราได้รับนั้น x_n = (2 b ^ 3 + c ^ 3) / (3 b ^ 2 cc ^ 3) สมมุติว่าเราเริ่มจาก 1 สิ่งนี้จะเกิดขึ้นเมื่อ x = 2 เพราะ x> 1 และเป็นจำนวนเต็ม รหัสที่ระบุและแสดงความคิดเห็น:

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 ไบต์

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

PHP Sandbox ออนไลน์

สร้างPadovan Spiralและพิมพ์อัตราส่วนของตัวเลขสองตัวสุดท้าย

ความจริง 96 ไบต์

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

ผล

(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

วิธีที่คุณสามารถดู h (2) ควรเป็น 1.32 และไม่ใช่ 1.33 ดังนั้นจึงมีข้อผิดพลาดในตัวเลขสุดท้าย

จากนั้นจะมีหนึ่งใน 110 ไบต์นี้

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)

มันใช้สูตรสำหรับการแก้สมการของเกรด III ของประเภท x ^ 3-3 * p * x-2 * q = 0 ในกรณี q ^ 2-p ^ 3> = 0 นั่นคือ m = sqrt (q ^ 2- p ^ 3) และ x = (q + m) ^ (1/3) + (qm) ^ (1/3)

ในกรณีของเรา r ^ 3-r-1 = 0 สามารถเขียนเป็น r ^ 3-3 * (1/3) r-2 * (1/2) = 0 ดังนั้น p = 1/3 q = 1/2 m = 1 / 4-1 / 27 = 23/108 x = (0.5 + m) ^ (1/3) + (0.5-m) ^ (1/3)

อันนี้ใช้การวนนิวตันกับจุดเริ่มต้น r = 1

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)

มันเปลี่ยนไปในฟังก์ชั่นค่าตัวเลขสำหรับรับหนึ่ง obj ของ n + 1 หลักหลังจุดลอย ในตอนท้ายค่าตัวเลข () จะถูกกำหนดกลับไปเป็นค่าล่วงหน้า

Ruby , 35 ไบต์

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

ลองออนไลน์!