Các thách thức

Số nhựa là một số liên quan đến tỷ lệ vàng, với nhiều tính chất toán học thú vị. Như vậy, có nhiều cách tiếp cận có thể được sử dụng để tính toán số lượng.

Để chỉ định chính xác số cho mục đích của thử thách này, chúng tôi sẽ sử dụng định nghĩa sau (mặc dù có rất nhiều định nghĩa tương đương và bạn có thể sử dụng bất kỳ định nghĩa nào bạn muốn miễn là cùng số đó):

Số nhựa là một số thực ρ như rằng ρ ³ = ρ 1.

Thách thức của bạn là viết một chương trình hoặc chức năng mà phải mất một số nguyên x như là đầu vào (với x > 1), và tạo ra một xấp xỉ để ρ như đầu ra, như vậy mà càng lớn thì giá trị của x được, càng gần đầu ra được đến ρ ( với ít nhất hữu hạn nhiều ngoại lệ; tạm trú tại đếm giá trị tương tự như "gần gũi" cho mục đích này), và đối với bất kỳ số dương δ , có một số đầu vào x để chương trình của bạn mà tạo ra một đầu ra rằng trong vòng δ của ρ .

Làm rõ

• Nếu bạn xuất ra thông qua một phương thức vốn xuất ra các chuỗi (ví dụ: luồng đầu ra tiêu chuẩn), bạn có thể định dạng đầu ra ở dạng thập phân (ví dụ 1.3247179572) hoặc theo tỷ lệ của hai số nguyên với một /ký tự giữa chúng.
• Nếu bạn xuất ra dưới dạng một giá trị trong ngôn ngữ lập trình của bạn (ví dụ: trả về từ một hàm), thì đó phải là loại điểm cố định, dấu phẩy động hoặc loại hợp lý. (Cụ thể, bạn không thể sử dụng các loại dữ liệu lưu trữ số một cách tượng trưng, ​​trừ khi chúng chỉ được sử dụng để giữ tỷ lệ của hai số nguyên. Vì vậy, nếu bạn đang sử dụng Mathicala hoặc một ngôn ngữ tương tự, bạn sẽ cần bao gồm thêm mã để thực sự tạo ra các chữ số của đầu ra.)
• Câu trả lời của bạn phải hoạt động theo một biến thể giả định của ngôn ngữ của bạn, trong đó số nguyên có thể lớn tùy ý và bộ nhớ (bao gồm cả ngăn xếp) là không giới hạn. Bạn không được cho rằng số học dấu phẩy động trong ngôn ngữ của mình là chính xác tùy ý, nhưng thay vào đó phải sử dụng độ chính xác thực tế của nó (có nghĩa là việc xuất ra một số dấu phẩy động chỉ có thể có trong các ngôn ngữ có thể có độ chính xác của các số dấu phẩy động kiểm soát lúc chạy).
• x có thể có bất kỳ ý nghĩa nào bạn muốn (miễn là tăng nó sẽ cho đầu ra chính xác hơn). Tôi tưởng tượng rằng hầu hết các bài nộp sẽ kiểm soát số chữ số đầu ra để tạo ra hoặc số lần lặp của thuật toán được sử dụng bởi chương trình của bạn để hội tụ số nhựa, nhưng các ý nghĩa khác đều được chấp nhận.

Testcase

Dưới đây là một vài chữ số đầu tiên của số nhựa:

1.32471795724474602596090885

Nhiều chữ số có sẵn trên OEIS .

Điều kiện chiến thắng

Như thường lệ đối với môn đánh gôn , ngắn hơn là tốt hơn, được đo bằng byte. Tuy nhiên, vui lòng gửi câu trả lời ngay cả khi họ không giành chiến thắng, miễn là họ thêm một cái gì đó (ví dụ: một ngôn ngữ khác hoặc thuật toán khác) vào các câu trả lời hiện có.

Python 2 , 49 byte

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

Hãy thử trực tuyến!

Ý tưởng là biểu thị ρvới ρ³=ρ+1một phân số n/xcó mẫu số xlà tham số độ chính xác đầu vào. Chúng tôi lấy (n/x)³=n/x+1và xóa mẫu số để có được n³=x²(x+n).

Vì LHS tăng nnhanh hơn RHS, chúng tôi có thể tính gần đúng điểm bằng nhau nlà nhỏ nhất với n³≥x²(x+n). Mã được tính ncho đến khi đây là trường hợp, bắt đầu từ xđó nhỏ hơn.

Một lưu byte nhỏ là chia cả hai bên x²để ghi n³/x²≥x+n(phủ định trong whileđiều kiện). Đây là phân chia sàn trong mã, nhưng phần bị mất là không đáng kể.

Một thay thế có cùng độ dài thay vì đặt xnhư tử số:

Con trăn 2 , 49 byte

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

Hãy thử trực tuyến!

Toán học, 20 byte

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

RootHàm dựng sẵn của Mathematica đưa ra các giải pháp cho phương trình đa thức f[x] == 0.

Giải trình

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

Mẫu 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

Toán học, 27 byte

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

-1 byte từ Martin
-2 byte từ ovs

đầu vào

[27]

đầu ra

{1.32471795724474602596090885}

sed , 67 60 (59 + 1) byte

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

Hãy thử trực tuyến!

+1 cho -Ecờ (ERE thay vì BRE). Đầu vào và đầu ra đều là đơn nguyên: đầu vào 1111 cho x = 5, ví dụ: Đầu ra là một phần của hai số đơn nguyên: đầu vào 1111 đã nói ở trên mang lại đầu ra 1111/1111 (5/4 theo số thập phân).

Xấp xỉ số nhựa là một phần giữa các phần tử liên tiếp của chuỗi Padovan .

Toán học, 27 byte

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

Sử dụng một xấp xỉ rút gọn của dạng gốc khối lồng nhau (1 + (1 + (1 + ...))) . Mặc dù đầu ra sẽ luôn có các vị trí thập phân x-1 , nhưng kết quả thực sự kém chính xác hơn bởi vì biểu thức hội tụ chậm hơn một chữ số trên mỗi lần lặp ( x cũng được sử dụng làm số gốc được lồng vào nhau được tính toán). Ví dụ x = 100 cho

_________________________________________________________________________
1.324717957244746025960908854478097340734404056901733364534015050302827850993693624204577670741656151

trong đó phần gạch chân là chính xác.

Octave , 50 byte

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

Hãy thử trực tuyến!

Xác định một hàm ẩn danh, với nsố chữ số đầu ra mong muốn.

Câu trả lời này lạm dụng rằng digits trả về cài đặt hiện tại cho số chữ số trong số học chính xác có thể thay đổi. Điều này có nghĩa là chúng ta chỉ có thể sử dụng nó trong một hàm ẩn danh mà không có lỗi về 'Quá nhiều đối số đầu ra'.

Ngoài ra, nó thực sự đơn giản: vpasolveviết tắt của Biến số học chính xác biến thiên, với độ chính xác được đặt theo lệnh gọi cuối cùng của digits. Vì vpalà kiểu dữ liệu Tượng trưng trong Octave, bị cấm theo thông số kỹ thuật, chúng tôi chỉ cần bọc toàn bộ hàm char(...)để lấy đầu ra chuỗi. Lưu ý rằng trong solvevà vpasolve, f==0được ngụ ý, vì vậy r^3==r+1đã được thay thế bởir^3-r-1 (==0)

MATL ( 27 28 byte)

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

Giải pháp đầu tiên của tôi (27 byte)

Hãy thử trực tuyến!

Nó chắc chắn không tối ưu, tôi vẫn đang làm quen với MATL.

Giải trình:

Tôi tạo một chuỗi Padovan lên đến đầu vào + 3 sau đó tìm tỷ lệ của hai số cuối.

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 ρ

Đầu ra phân số thích hợp (35 byte) (28 byte, @Sanchises):

Tuy nhiên, giải pháp đầu tiên không đáp ứng nhu cầu về độ chính xác tùy ý là giới hạn dấu phẩy động của cài đặt MATL mặc định. Vì vậy, thay vì thêm một vài byte để mở rộng độ chính xác này, nó đơn giản để có những tuyến đường phần phù hợp và viết một phần nhỏ của hai số nguyên cuối cùng trong (N-1) ^thứ và N ^thứ yếu tố của chuỗi Padovan cắt ngắn.

ví dụ: "114/86"

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

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

Phép lịch sự của người dùng @Sanchises. :)

Hãy thử trực tuyến!

Đánh giá không lặp lại:

Đáng chú ý, mã ngắn nhất của tôi cho phiên bản 'chính xác' là (23 byte):

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

Hãy thử trực tuyến!

... nhưng không cho độ chính xác tùy ý. Tôi tự hỏi nếu bất cứ ai có thể điều chỉnh điều này để thực hiện các quy tắc (sử dụng đầu vào, vv) và vẫn thêm ít hơn 5 byte? : P

M , 15 14 byte

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

Hãy thử trực tuyến!

Thuật toán

Điều này sử dụng hợp lý và phương pháp của Newton. Cụ thể, đối với đầu vào x , lần lặp x đầu tiên có giá trị bắt đầu x được áp dụng.

Chúng tôi đang cố gắng tìm một gốc cụ thể của đa thức p (t) = t³ - t - 1 . Phương pháp của Newton đạt được điều này bằng cách lấy giá trị bắt đầu t ₀ - đủ gần với ρ - và xác định đệ quy một chuỗi theo
t _{n + 1} = t _n - p (t _n ) / p '(t _n ) .

Vì p '(t) = 3t² -1 , nên ta nhận được
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) .

Lưu ý rằng xấp xỉ ban đầu x sẽ ngày càng tệ hơn khi x tăng. Trong khi đầu ra cho x = 3 là hơi ít chính xác hơn so với đầu ra cho x = 2 , vì phương pháp hội tụ của Newton bậc hai để ρ , đây không phải là một vấn đề đối với giá trị lớn của x .

Làm thế nào nó hoạt động

Ç¡    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 byte

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

Sử dụng hợp lý và phương pháp của Newton.

Hãy thử trực tuyến!

05AB1E , 23 byte

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

Hãy thử trực tuyến!

Cổng trực tiếp của /codegolf//a/126822/59376 bởi xnor.

Than , 28 byte

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

Hãy thử trực tuyến! Liên kết với chế độ dài dòng. Ngoài ra tôi rõ ràng đã nhắn tin Dividevà IntDivide: |
Sử dụng phương pháp tương tự như câu trả lời của Python và JavaScript.

NewStack , 14 byte

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

Phá vỡ:

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

Làm thế nào nó hoạt động:

Công thức (2x ³ +1) / (3x ² -1) xuất phát từ việc đơn giản hóa phương pháp của Newton cho phương trình x ³ = x + 1. Bạn có thể tìm thấy nó ở đây . Lặp đi lặp lại quá trình này vô số lần hội tụ đến số nhựa. Tốc độ hội tụ của nó khá nhanh với khoảng 2,6 số thập phân mỗi lần lặp.

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

Trình tự thay thế Padovan, 27 25 17 byte

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

Phá vỡ:

¹                  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 byte bằng cách chọn chiến lược in tốt hơn

-8 byte bằng cách chọn cách tốt hơn để lập chỉ mục ngăn xếp

Làm thế nào nó hoạt động:

Khi chuỗi Padovan tiếp tục, tỷ lệ của hai yếu tố cuối cùng hội tụ với số nhựa.

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

Clojure, 46 byte

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

Sử dụng công thức gốc lập phương lặp. Điều này thú vị hơn một chút nhưng lâu hơn:

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

((f 10)1)
1.3247179361449652

Javascript, 36 byte

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

Hoạt động tương tự như câu trả lời python hàng đầu. Không console.logđược bao gồm bởi vì nếu bạn chạy f(x)trong giao diện điều khiển, nó sẽ được ghi lại tự động.

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

> <> , 38 + 3 = 41 byte

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

Dự kiến ​​đầu vào sẽ xuất hiện trên ngăn xếp khi bắt đầu chương trình, vì vậy +3 byte cho -vcờ.

Hãy thử trực tuyến!

Hiệu quả thực hiện tìm kiếm nhị phân để thu hẹp giá trị đầu ra. Tăng xlàm tăng số lần lặp để thực hiện.

Chỉnh sửa: tính toán tái cấu trúc một chút để tiết kiệm 1 byte, phiên bản trước:

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

k, 27 byte

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

Hãy thử trực tuyến! Điều này giả định số nguyên vô hạn (mà, than ôi, là không đúng). Nó sử dụng trình tự Padovan .

TI-BASIC, 21 byte

: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

Sử dụng công thức đệ quy này .

Thật thú vị, mã hóa cứng số và làm tròn số đó cho cùng một số byte:

TI-BASIC, 21 byte

: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

Sử dụng công thức lượng giác này .

C # , 317 byte

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

Nó trả về kết quả dưới dạng phân số.

Giải trình

Nó sử dụng phương pháp của Newton với các lần lặp x để tìm gốc của đa thức p ^ 3-p-1 = 0. Công thức là x_n = 1- (f (x_ (n-1))) / (f '(x_ (n-1))) và x_0 là điểm bắt đầu.

Đạo hàm đa thức là 3p ^ 2-1 và giả sử x_ (n-1) = b / c. Sau đó, bằng cách sử dụng công thức trên mà chúng tôi nhận được, x_n = (2 b ^ 3 + c ^ 3) / (3 b ^ 2 cc ^ 3). Chúng ta cũng nói rằng, chúng ta bắt đầu từ 1, điều này sẽ xảy ra, khi x = 2, vì x> 1 và là một số nguyên. Mã đã nhận biết và nhận xét:

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 byte

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

PHP Sandbox trực tuyến

Tạo xoắn ốc Padovan và in tỷ lệ của hai số cuối.

Tiên đề, 96 byte

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

các kết quả

(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

Làm thế nào bạn có thể thấy h (2) phải là 1.32 chứ không phải 1.33 nên có một số lỗi trong các chữ số cuối

Sau đó, sẽ có một trong 110 byte

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)

Nó sử dụng công thức để giải phương trình loại III loại x ^ 3-3 * p * x-2 * q = 0 trong trường hợp q ^ 2-p ^ 3> = 0 đó là m = sqrt (q ^ 2- p ^ 3) và x = (q + m) ^ (1/3) + (qm) ^ (1/3)

Trong trường hợp của chúng tôi r ^ 3-r-1 = 0, điều này có thể được viết là r ^ 3-3 * (1/3) r-2 * (1/2) = 0 nên p = 1/3 q = 1/2 m = 1 / 4-1 / 27 = 23/108 x = (0,5 + m) ^ (1/3) + (0,5-m) ^ (1/3)

cái này sử dụng phép lặp Newton với điểm bắt đầu 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)

nó thay đổi trong hàm, giá trị chữ số để có được một obj gồm n + 1 chữ số sau điểm nổi. Cuối cùng, giá trị chữ số () được gán lại cho giá trị trước.

Ruby , 35 byte

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

Hãy thử trực tuyến!