Meydan okuma

Plastik sayı birçok ilginç matematiksel özellikleri olan altın oranına ilişkin bir numaradır. Bu nedenle, sayıyı hesaplamak için kullanılabilecek birçok yaklaşım vardır.

Bu zorluğun amaçları için numarayı tam olarak belirtmek için, aşağıdaki tanımı kullanacağız (birçok eşdeğer tanım olmasına rağmen ve aynı numaraya geldiği sürece istediğiniz herhangi bir tanımı kullanabilirsiniz):

Plastik numara bir gerçek sayı olduğu ρ şekilde ρ ³ = ρ + 1.

Buradaki zorluk, bir tamsayıdır alan bir program ya da fonksiyonu yazmak için x ile (giriş olarak x > 1), ve bir yaklaşma üreten p'ye daha büyük bir değer, öyle ki çıkış olarak x alır, daha yakın çıkış alır p'ye ( en sonlu sayıda istisna dışında en ile; bu amaçla "daha yakın" ile aynı değer sayıları kaldıkları) ve herhangi bir pozitif sayı için ö , bazı giriş var x içinde çıktı o en üretir programınıza ö ait p'ye .

Açıklamalar

• Dizeleri doğal olarak çıkaran bir yöntemle (örneğin standart çıktı akışı) çıktı alıyorsanız, çıktıyı ondalık (örneğin 1.3247179572) olarak veya /aralarında karakterli iki tam sayı oranı olarak biçimlendirebilirsiniz .
• Programlama dilinizde bir değer olarak çıktı veriyorsanız (örneğin bir işlevden döndürme), sabit nokta, kayan nokta veya rasyonel tipte olmalıdır. (Özellikle, yalnızca iki tamsayının oranını tutmak için kullanılmadıkça, sayıları sembolik olarak depolayan veri türlerini kullanamazsınız. Dolayısıyla, Mathematica veya benzer bir dil kullanıyorsanız, fazladanları eklemeniz gerekir. gerçekten çıktının rakamlarını oluşturmak için kod.)
• Cevabınız, tam sayıların keyfi olarak büyük olabileceği ve hafızanın (yığın dahil) sınırsız olduğu, dilinizin varsayımsal bir varyantında çalışmalıdır. Sen olabilir değil kendi dilinizde o kayan nokta aritmetik keyfi doğru olduğunu varsayalım, ancak bunun yerine (bir kayan nokta sayı çıkışında sadece kayan noktalı sayıların doğruluğu olabildiği dilde mümkün olacak anlamına gerçek doğruluk kullanmalıdır çalışma zamanında kontrol edilir).
• x istediğiniz herhangi bir anlama sahip olabilir (arttırılması daha doğru çıktılar sağladığı sürece). Çoğu gönderimin, üretilecek çıktının sayısını ya da programınız tarafından plastik numara üzerinde birleşmek için kullanılan algoritmanın yineleme sayısını kontrol edeceğini hayal ediyorum, ancak diğer anlamlar kabul edilebilir.

Test durumu

İşte plastik sayının ilk birkaç hanesi:

1.32471795724474602596090885

OEIS'te daha fazla rakam var .

Zafer durumu

Kod golf için her zaman olduğu gibi , bayt cinsinden ölçülen kısa olan daha iyidir. Bununla birlikte, mevcut cevaplara bir şey ekledikleri sürece (örneğin farklı bir dil veya farklı bir algoritma) kazandıklarında bile cevaplar göndermekten çekinmeyin.

Python 2,49 bayt

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

Çevrimiçi deneyin!

Fikri bildirmektir ρile ρ³=ρ+1bir kısmı olarak n/xolan payda xgiriş doğruluğu parametredir. Almak (n/x)³=n/x+1ve paydaları temizlemek n³=x²(x+n).

LHS, RHS'den ndaha hızlı arttığından , eşitlik noktasını nen küçük değer olarak tahmin edebiliriz n³≥x²(x+n). Kod n, başladığından xdaha küçük olana kadar sayar .

Küçük bir bayt tasarrufu, her iki tarafı x²da yazarak bölmek n³/x²≥x+n(koşulsuz while). Bu koddaki kat bölümüdür, ancak kaybedilen bölüm kaybedilmez.

Aynı uzunluktaki bir alternatif bunun yerine paylayıcıyı koyar x:

Python 2,49 bayt

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

Çevrimiçi deneyin!

Mathematica, 20 bayt

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

Mathematica'nın yerleşik Rootişlevi, bir polinom denklemine çözümler sunar f[x] == 0.

açıklama

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

Örnek 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 bayt

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

Martin'den -1 bayt
ovs'den -2 bayt

giriş

[27]

çıktı

{1,32471795724474602596090885}

sed , 67 60 (59 + 1) bayt

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

Çevrimiçi deneyin!

-EBayrak için +1 (BRE yerine ERE). Girdi ve çıktı her ikisi de aynıdır: x = 5 için giriş 11111, örneğin Çıkış iki unary sayısının bir kesridir: yukarıda belirtilen 11111 giriş çıkışı 11111/1111 (ondalık sayıda 5/4) verir.

Plastik sayıya, Padovan dizisinin ardışık elemanları arasındaki bir kesir olarak yaklaşır .

Mathematica, 27 bayt

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

Yuvalanmış kübik radikal formunun appro (1 + ³√ (1 + ³√ (1 + ...))) kesikli bir yaklaşımını kullanır . Çıktı her zaman x-1 ondalık basamağa sahip olsa da , sonuç aslında bundan daha az doğrudur, çünkü ifade, her yineleme için bir basamaktan daha yavaş bir şekilde birleşir ( x , hesaplanan iç içe geçmiş radikallerin sayısı olarak da kullanılır). Örneğin x = 100 verir

_________________________________________________________________________
1.324717957244746025960908854478097340734404056901733364534015050302827850993693624204577670741656151

altı çizili bölümün doğru olduğu yerde.

Oktav , 50 bayt

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

Çevrimiçi deneyin!

nİstenilen sayı basamağı olan adsız bir işlevi tanımlar .

Bu cevap kötüye digits , değişken hassas aritmetik olarak basamak sayısının geçerli ayarını döndürür. Bu, anonim bir işlevde 'Çok fazla çıktı argümanı' hatası olmadan kullanabileceğimiz anlamına gelir.

Bunun dışında, gerçekten basittir: vpasolveDeğişken-Hassas Aritmetik Çözümü için son çağrı tarafından ayarlanan hassasiyetle kısa digits. Yana vpaspesifikasyonları uyarınca yasak Octave bir Sembolik veri tipidir, sadece bütün fonksiyonlarını sarın char(...)dize çıktısını almak için. İçinde olduğunu unutmayın solveve vpasolve, f==0ima, bu nedenle r^3==r+1almıştırr^3-r-1 (==0)

MATL ( 27 28 bayt)

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

İlk çözümüm (27 bayt)

Çevrimiçi deneyin!

Bu kesinlikle optimal değil, ben hala MATL'a alışıyorum.

Açıklama:

Giriş + 3'e kadar bir Padovan dizisi oluşturup son iki sayının oranını buldum.

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 ρ

Doğru kesir çıkışı (35 bayt) (28 bayt, @Sanchises):

Ancak, ilk çözüm, varsayılan MATL ayarlarının kayan nokta sınırı olan keyfi hassasiyet ihtiyacını karşılamıyor. Yani daha doğrusu bu hassas uzatmak için birkaç bayt ekleyerek yerine, tam kesir yol almak ve (N-1) 'de son iki tamsayılar bir kısmını yazmak için basittir ^inci ve N ^inci kesildi Padovan dizinin elemanları.

örneğin "114/86"

7BG: "T @) y '+ 1) + H] TG3 +) V '/' YcyG2 +) VYC

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

Kullanıcının @Sanchises izniyle. :)

Çevrimiçi deneyin!

Yinelemeli olmayan değerlendirme:

Özellikle, 'kesin' sürüm için en kısa kodum (23 bayt):

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

Çevrimiçi deneyin!

... fakat keyfi bir hassasiyet vermez. Acaba kimse bunu kurallara uyması için ayarlayabilir mi (girişi vb. Kullanın) ve hala 5 bayttan daha az ekleyebilir mi? : P

M , 15 14 bayt

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

Çevrimiçi deneyin!

Algoritma

Bu, rasyonelleri ve Newton'un yöntemini kullanır. Özellikle, giriş için x , birinci x başlangıç değeri olan yineleme x uygulanır.

Polinomun belirli bir kökünü bulmaya çalışıyoruz p (t) = t³ - t - 1 . Newton'un metodu bunu, t ₀ - yeterince ρ'ya yakın bir başlangıç ​​değeri alarak - ve bir diziyi tekrar tekrar
t _{n + 1} = t _n - p (t _n ) / p '(t _n ) ile tanımlayarak başarır .

Yana p (t) = 3t² -1 , elde ederiz
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) .

İlk yaklaşımın x , x arttıkça aşamalı olarak kötüleştiğini unutmayın . X = 3 için çıktı, çıktıdan biraz daha az hassas olsa da x = 2 , Newton’un metodu ikinci dereceden ρ’ya yaklaştığından , bu büyük x değerleri için bir sorun olmamalıdır .

Nasıl çalışır

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

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

Gerekçeleri ve Newton'un yöntemini kullanır.

Çevrimiçi deneyin!

05AB1E , 23 bayt

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

Çevrimiçi deneyin!

Xnor tarafından /codegolf//a/126822/59376 numaralı direkt bağlantı noktası .

Kömür , 28 bayt

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

Çevrimiçi deneyin! Ayrıntılı moda bağlantı. Ayrıca görünüşe göre berbat Divideve IntDivide: |
Python ve JavaScript cevaplarıyla aynı yöntemi kullanır.

NewStack , 14 bayt

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

Yıkmak:

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

Nasıl çalışır:

Formül (2x ³ + 1) / (3x ² -1) basitleştirilmesi gelir Newton yöntemi equasion X için ³ = x + 1. Burada bulabilirsiniz . Bu işlem tekrarlanırsa, sonsuz sayıda bir sayı plastik sayıya yakınlaşır. Yakınsama hızı, yineleme başına yaklaşık 2,6 ondalık basamakta oldukça hızlıdır.

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 dizi alternatifi, 27 25 17 bayt

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

Yıkmak:

¹                  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 daha iyi baskı stratejisi seçerek

-8 bayt yığını dizine daha iyi bir yol seçerek

Nasıl çalışır:

Olarak Padovan sekans devam eder, son iki element oranının plastik sayıda birleşir.

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

Clojure, 46 bayt

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

Yinelenmiş küp-kök formülünü kullanır. Bu biraz daha ilginç ama daha uzun:

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

((f 10)1)
1.3247179361449652

Javascript, 36 bayt

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

Üst python cevabı ile aynı şekilde çalışır. Hayır console.logdahil edildi, çünkü eğer f(x)konsolda koşarsanız otomatik olarak kaydedilir.

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

> <> , 38 + 3 = 41 bayt

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

Girişin program başlangıcında yığında olmasını, -vbayrak için +3 bayt olmasını bekler .

Çevrimiçi deneyin!

Çıktı değerini daraltmak için etkili bir ikili arama gerçekleştirir. Artırmak x, gerçekleştirilecek yineleme sayısını artırır.

Düzenleme: 1 bayt, önceki sürüm kaydetmek için refactored hesaplama

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

k, 27 bayt

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

Çevrimiçi deneyin! Bu sonsuz tamsayılar (ki ne yazık ki doğru değil) varsayar. Padovan dizisini kullanır .

TI-BASIC, 21 bayt

: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

Bu özyinelemeli formülü kullanır .

İlginçtir ki, sayıyı kodlamak ve yuvarlamak aynı bayt sayısını verir:

TI-BASIC, 21 bayt

: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

Bu trigonometrik formülü kullanır .

C # , 317 bayt

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

Sonucu kesir olarak döndürür.

açıklama

Newton'un x yinelemeli yöntemini kullanarak, polinomun p ^ 3-p-1 = 0 kökünü bulmak için kullanır. Formül x_n = 1- (f (x_ (n-1))) / (f '(x_ (n-1))) ve x_0 bir başlangıç ​​noktasıdır.

Polinom türevi 3p ^ 2-1'dir ve diyelim ki x_ (n-1) = b / c. Daha sonra, yukarıdaki formülü kullanarak, şunu elde ederiz ki, bu x_n = (2 b ^ 3 + c ^ 3) / (3 b ^ 2 cc ^ 3). Ayrıca 1'den başlayacağımızı söyleyelim, bu x = 2 olduğunda olur, çünkü x> 1 ve bir tamsayıdır. Tanımlı ve yorumlanmış kod:

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 bayt

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

PHP Sandbox Çevrimiçi

Padovan Spiral'i oluşturur ve son iki sayının oranını yazdırır.

Aksiyom, 96 bayt

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

Sonuçlar

(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) 'yi nasıl görüyorsunuz 1.32 olmalı ve 1.33 olmamalı, bu yüzden son rakamlarda bazı hatalar var.

Sonra 110 baytlık bir tane olurdu.

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)

Q ^ 2-p ^ 3> = 0 olması durumunda, m = sqrt (q ^ 2- olması durumunda, x ^ 3-3 * p * x-2 * q = 0 tipindeki III denklemini çözmek için formülü kullanır. p ^ 3) ve x = (q + m) ^ (1/3) + (qm) ^ (1/3)

Bizim durumumuzda r ^ 3-r-1 = 0, bu, r ^ 3-3 * (1/3) r-2 * (1/2) = 0 şeklinde yazılabilir; p = 1/3 q = 1/2 m = 1 / 4-1 / 27 = 23/108 x = (0.5 + m) ^ (1/3) + (0.5-m) ^ (1/3)

Newton iterasyonunu başlangıç ​​noktası r = 1 ile kullanan bu

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)

işlevde değişir, kayan noktadan sonra n + 1 hane bir objeyi elde etmek için hane değeri. Sonunda digits () değeri ön değere geri verilir.

Ruby , 35 bayt

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

Çevrimiçi deneyin!