도전

플라스틱 수 많은 흥미로운 수학적 특성을 가진 황금 비율에 관련된 숫자입니다. 따라서 숫자를 계산하는 데 사용할 수있는 많은 방법이 있습니다.

이 과제의 목적을 위해 숫자를 정확하게 지정하기 위해 다음과 같은 정의를 사용합니다 (동일한 정의가 많더라도 원하는 숫자를 같은 숫자로 사용할 수 있음).

소성 숫자는 실수 ρ 이므로 ρ ³ = ρ +1입니다.

내 도전 정수 얻어 프로그램이나 함수를 작성하는 , X가 (로 입력으로서 X > 1)가 근사치를 생성 ρ 의 값이 클수록되도록, 출력으로서 X는 얻는다 가까운 출력에 도달 ρ를 ( 대부분의 유한 한 많은 예외로하여,이 목적을 위해 "더 가까이"와 같은 값 카운트에서 체류) 및 양수에 대한 δ , 일부 입력있다 X 내에서 출력이의 생산 프로그램에 δ 의 ρ를 .

설명

• 기본적으로 문자열을 출력하는 방법 (예 : 표준 출력 스트림)을 통해 출력하는 경우 10 진수 (예 :) 1.3247179572또는 /문자 사이 의 문자 를 갖는 두 정수의 비율로 출력을 형식화 할 수 있습니다.
• 프로그래밍 언어 내에서 값으로 출력하는 경우 (예 : 함수에서 반환) 고정 소수점, 부동 소수점 또는 합리적인 유형이어야합니다. (특히 두 정수의 비율을 유지하는 데만 사용되지 않는 한 숫자를 기호로 저장하는 데이터 유형을 사용할 수 없습니다. 따라서 Mathematica 또는 유사한 언어를 사용하는 경우 추가를 포함해야합니다. 실제로 출력의 숫자를 생성하는 코드입니다.)
• 답은 정수가 임의로 클 수 있고 메모리 (스택 포함)가 무제한 인 가상의 언어 변형에서 작동해야합니다. 당신은 할 수 없는 언어에서 그 부동 소수점 연산 임의로 정확 가정, 대신 (부동 소수점 숫자를 출력하는 경우에만 부동 소수점 숫자의 정확성이 될 수있는 언어로 가능 위하여려고하고 있다는 것을 의미한다 실제 정확성을 사용해야합니다 런타임에 제어 됨).
• x 는 원하는 의미를 가질 수 있습니다 (확장할수록 더 정확한 출력을 제공하는 한). 나는 대부분의 제출물이 생성 할 출력 자릿수 또는 프로그램이 플라스틱 수에 수렴하기 위해 사용하는 알고리즘의 반복 횟수를 제어해야한다고 생각하지만 다른 의미는 허용됩니다.

테스트 케이스

플라스틱 번호의 처음 몇 자리는 다음과 같습니다.

1.32471795724474602596090885

OEIS에서 더 많은 숫자를 사용할 수 있습니다 .

승리 조건

code-golf 와 마찬가지로 바이트 단위로 짧을수록 좋습니다. 그러나 기존 답변에 다른 언어 (예 : 다른 언어 또는 다른 알고리즘)를 추가하는 한, 당첨되지 않더라도 답변을 게시 할 수 있습니다.

파이썬 2 , 49 바이트

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

온라인으로 사용해보십시오!

아이디어는 분모 가 입력 정확도 매개 변수 인 분수 로 로 표현하는 것 ρ입니다 . 우리는 분모를 취하고 지 웁니다 .ρ³=ρ+1n/xx(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이 분자로 대신 사용됩니다 .

파이썬 2 , 49 바이트

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

온라인으로 사용해보십시오!

Mathematica, 20 바이트

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

Mathematica의 내장 Root함수는 다항식에 솔루션을 제공합니다 f[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

수학, 27 바이트

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

Martin에서 -1 바이트
ovs에서 -2 바이트

입력

[27]

산출

{1.32471795724474602596090885}

sed , 67 60 (59 + 1) 바이트

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

온라인으로 사용해보십시오!

-E플래그에 대해 +1 (BRE 대신 ERE). 입력과 출력은 모두 단항입니다 : x = 5의 경우 입력 11111 예 : 출력은 두 개의 단항 숫자의 일부입니다 : 위에서 언급 한 11111 입력은 출력 11111/1111 (10 진수 5/4)을 산출합니다.

파도바 시퀀스 의 연속 요소 사이의 분수로 플라스틱 수를 근사합니다 .

수학, 27 바이트

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

중첩 된 큐빅 라디칼 형태 ³√ (1 + ³√ (1 + ³√ (1 + ...))) 의 잘린 근사법을 사용합니다 . 출력은 항상 x-1 소수 자릿수를 갖지만 식은 반복 당 한 자리보다 느리게 수렴하기 때문에 결과는 실제로 정확도가 떨어집니다 ( x 는 계산 된 중첩 라디칼의 수로도 사용됨). 예를 들어 x = 100 은

_________________________________________________________________________
1.324717957244746025960908854478097340734404056901733364534015050302827850993693624204577670741656151

겹친 부분이 올바른 곳.

옥타브 , 50 바이트

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

온라인으로 사용해보십시오!

n원하는 출력 자릿수로 익명 함수를 정의합니다 .

이 대답 digits은 변수 정밀도 산술의 자릿수에 대한 현재 설정을 반환하는 악용입니다 . 즉, '너무 많은 출력 인수'에 대한 오류없이 익명 함수에서 사용할 수 있습니다.

그 외에는 매우 간단합니다. vpasolve마지막 정밀도 호출에서 설정 한 정밀도로 Variable-Precision Arithmetic Solve의 줄임말입니다 digits. vpa스펙에 따라 금지 된 Octave의 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에 여전히 익숙합니다.

설명:

내가 만드는 파도 반 순서를 다음 마지막 두 숫자의 비율을 찾을 입력 + 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)의 마지막 두 개의 정수의 일부를 작성 간단 ^번째 와 N ^번째의 버림 파도 반 시퀀스의 요소.

예 : "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 바이트 미만을 추가하도록 조정할 수 있는지 궁금합니다. :피

M , 15 14 바이트

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

온라인으로 사용해보십시오!

연산

이것은 합리성과 뉴턴의 방법을 사용합니다. 특히, 입력 x의 경우 시작 값 x 의 첫 x 반복 이 적용됩니다.

다항식 p (t) = t³-t-1 의 특정 근을 찾으려고합니다 . Newton의 방법은 시작 값 t ₀ – ρ에 충분히 근접한 – 를 취하고
t _{n + 1} = 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 뉴턴 방법의 수렴이 차적으로하기 때문에, ρ , 이것은 큰 문제 값이어야한다 (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.

줄리아 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

온라인으로 사용해보십시오!

xnor 의 /codegolf//a/126822/59376의 직접 포트 .

숯 , 28 바이트

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

온라인으로 사용해보십시오! 상세 모드로 연결합니다. 또한 나는 분명히 엉망 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)은 적도 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

파도바 시퀀스 대안, 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 바이트

작동 방식 :

애즈 파도 반 시퀀스가 계속 마지막 두 요소의 비율은 플라스틱 번호 모이다.

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

클로저, 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

자바 스크립트, 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-:}

프로그램 시작시 스택에 입력이있을 것으로 예상되므로 -v플래그의 경우 +3 바이트입니다 .

온라인으로 사용해보십시오!

이진 검색을 효과적으로 수행하여 출력 값을 좁 힙니다. 증가 x하면 수행 할 반복 횟수가 증가합니다.

편집 : 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

이 재귀 공식을 사용합니다 .

흥미롭게도 숫자를 하드 코딩하고 반올림하면 동일한 바이트 수를 얻습니다.

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

결과를 분수로 반환합니다.

설명

다항식 p ^ 3-p-1 = 0의 근을 찾기 위해 x 반복과 함께 Newton의 방법을 사용합니다. 공식은 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 샌드 박스 온라인

파도바 스파이럴을 생성하고 마지막 두 숫자의 비율을 인쇄합니다.

공리, 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.33이 아닌 1.32 여야하는 방법을 알 수 있으므로 마지막 숫자에 오류가 있습니다.

그러면 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)

그것은 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)

부동 소수점에 따라 n + 1 자리수의 하나의 obj를 얻기 위해 숫자 값이 함수에서 변경됩니다. 마지막에 numeric () 값이 우선 값으로 다시 지정됩니다.

루비 , 35 바이트

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

온라인으로 사용해보십시오!