La sfida

Il numero di plastica è un numero correlato al rapporto aureo, con molte proprietà matematiche interessanti. Pertanto, ci sono molti approcci che possono essere utilizzati per calcolare il numero.

Al fine di specificare con precisione il numero ai fini di questa sfida, useremo la seguente definizione (anche se ci sono molte definizioni equivalenti e puoi usare qualsiasi definizione desideri purché si tratti dello stesso numero):

Il numero di plastica è un numero reale ρ tale che ρ ³ = ρ +1.

La tua sfida è scrivere un programma o una funzione che accetta un intero x come input (con x > 1) e produce un'approssimazione a ρ come output, in modo tale che maggiore è il valore di x , più l'output si avvicina a ρ ( con al massimo fin troppe eccezioni, rimanendo allo stesso valore conta come "più vicino" per questo scopo) e per ogni numero positivo δ , c'è un input x nel tuo programma che produce un output che si trova entro δ di ρ .

chiarimenti

• Se si esegue l'output tramite un metodo che genera intrinsecamente stringhe (ad esempio il flusso di output standard), è possibile formattare l'output in decimali (ad esempio 1.3247179572) o come rapporto di due numeri interi con un /carattere tra loro.
• Se stai fornendo un valore all'interno del tuo linguaggio di programmazione (es. Ritorno da una funzione), deve essere di tipo a virgola fissa, a virgola mobile o razionale. (In particolare, non è possibile utilizzare tipi di dati che memorizzano i numeri in modo simbolico, a meno che non vengano utilizzati solo per contenere il rapporto di due numeri interi. Quindi, se si utilizza Mathematica o un linguaggio simile, è necessario includere codice per generare effettivamente le cifre dell'output.)
• La tua risposta deve funzionare in un'ipotetica variante della tua lingua in cui gli interi possono essere arbitrariamente grandi e la memoria (incluso lo stack) è illimitata. Si può non dare per scontato che in virgola mobile nella tua lingua è arbitrariamente accurata, ma deve invece utilizzare la sua effettiva accuratezza (il che significa che l'emissione di un numero a virgola mobile è solo andare a essere possibile in lingue in cui la precisione dei numeri in virgola mobile può essere controllato in fase di esecuzione).
• x può avere qualsiasi significato tu voglia (purché aumentandolo produca risultati più precisi). Immagino che la maggior parte degli invii controllerà il numero di cifre dell'output da produrre o il numero di iterazioni dell'algoritmo utilizzato dal programma per convergere sul numero di plastica, ma altri significati sono accettabili.

testcase

Ecco le prime cifre del numero di plastica:

1.32471795724474602596090885

Altre cifre sono disponibili su OEIS .

Condizione di vittoria

Come di consueto per il code-golf , il più breve è meglio, misurato in byte. Tuttavia, sentiti libero di pubblicare risposte anche se non vincono, purché aggiungano qualcosa (ad esempio una lingua diversa o un algoritmo diverso) alle risposte esistenti.

Python 2 , 49 byte

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

Provalo online!

L'idea è di esprimere il ρcon ρ³=ρ+1una frazione il n/xcui denominatore xè il parametro di precisione dell'input. Prendiamo (n/x)³=n/x+1e cancelliamo i denominatori per ottenere n³=x²(x+n).

Poiché l'LHS aumenta npiù rapidamente dell'RHS, possiamo approssimare il punto di uguaglianza ncome il più piccolo con n³≥x²(x+n). Il codice conta fino a nquando questo è il caso, a partire dal xquale è più piccolo.

Un piccolo byte di salvataggio consiste nel dividere entrambi i lati x²per scrivere n³/x²≥x+n(negato nella whilecondizione). Questa è la divisione del piano nel codice, ma la parte frazionaria persa è trascurabile.

Un'alternativa della stessa lunghezza invece mette xcome numeratore:

Python 2 , 49 byte

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

Provalo online!

Mathematica, 20 byte

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

La Rootfunzione integrata di Mathematica fornisce le soluzioni a un'equazione polinomiale f[x] == 0.

Spiegazione

#^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 di esempio

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 byte

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

-1 byte da Martin
-2 byte da ovs

ingresso

[27]

produzione

{} 1,32471795724474602596090885

sed , 67 60 (59 + 1) byte

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

Provalo online!

+1 per la -Ebandiera (ERE anziché BRE). Input e output sono entrambi unari: input 11111 per x = 5 ad es. Output è una frazione di due numeri unari: l'input 11111 sopra citato produce output 11111/1111 (5/4 in decimale).

Approssima il numero di plastica come una frazione tra elementi consecutivi della sequenza padovana .

Mathematica, 27 byte

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

Utilizza un'approssimazione troncata della forma radicale cubica nidificata ³√ (1 + ³√ (1 + ³√ (1 + ...))) . Mentre l'output avrà sempre posizioni decimali x-1 , il risultato è in realtà meno accurato di quello, poiché l'espressione converge più lentamente di una cifra per iterazione ( x viene utilizzato anche come numero di radicali nidificati calcolati). Ad esempio x = 100 dà

_________________________________________________________________________
1.324717957244746025960908854478097340734404056901733364534015050302827850993693624204577670741656151

dove la parte sottolineata è corretta.

Ottava , 50 byte

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

Provalo online!

Definisce una funzione anonima, con nil numero desiderato di cifre dell'output.

Questa risposta abusa che digitsrestituisce l'impostazione corrente per il numero di cifre in aritmetica a precisione variabile. Ciò significa che possiamo semplicemente usarlo in una funzione anonima senza errori su "Troppi argomenti di output".

A parte questo, è davvero semplice: vpasolveè l'abbreviazione di Risolvimento aritmetico a precisione variabile, con la precisione impostata dall'ultima chiamata di digits. Poiché vpaè un tipo di dati simbolico in Octave, che è vietato in base alle specifiche, è sufficiente racchiudere l'intera funzione char(...)per ottenere l'output della stringa. Si noti che in solvee vpasolve, il f==0è implicito, quindi r^3==r+1è stato sostituito dar^3-r-1 (==0)

MATL ( 27 28 byte)

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

La mia prima soluzione (27 byte)

Provalo online!

Non è certo ottimale, mi sto ancora abituando a MATL.

Spiegazione:

Creo una sequenza padovana fino a inserire + 3, quindi trovo il rapporto degli ultimi due numeri.

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 ρ

Output della frazione corretta (35 byte) (28 byte, @Sanchise):

Tuttavia, la prima soluzione non soddisfa la necessità di precisione arbitraria essendo il limite in virgola mobile delle impostazioni MATL predefinite. Quindi, piuttosto che aggiungere diversi byte per estendere questa precisione, è più semplice prendere la rotta della frazione corretta e scrivere una frazione degli ultimi due numeri interi (N-1) ^th e N ^th elementi della sequenza troncata di Padovan.

ad es. "114/86"

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

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

Per gentile concessione dell'utente @Sanchises. :)

Provalo online!

Valutazione non iterativa:

In particolare, il mio codice più breve per la versione 'esatta' è (23 byte):

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

Provalo online!

... ma non dà precisione arbitraria. Mi chiedo se qualcuno può aggiustarlo per soddisfare le regole (utilizzare l'input ecc.) E aggiungere comunque meno di 5 byte? : P

M , 15 14 byte

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

Provalo online!

Algoritmo

Questo utilizza razionali e il metodo di Newton. In particolare, per l'input x , vengono applicate le prime x iterazioni con valore iniziale x .

Stiamo cercando di trovare una radice specifica del polinomio p (t) = t³ - t - 1 . Il metodo di Newton raggiunge questo obiettivo prendendo un valore iniziale t ₀ - sufficientemente vicino a ρ - e definendo in modo ricorsivo una sequenza di
t _{n + 1} = t _n - p (t _n ) / p '(t _n ) .

Poiché p '(t) = 3t² -1 , otteniamo
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) .

Si noti che l'approssimazione iniziale x peggiora progressivamente all'aumentare di x . Mentre l'output per x = 3 è leggermente meno preciso dell'output per x = 2 , poiché il metodo di Newton converge quadraticamente in ρ , questo non dovrebbe essere un problema per grandi valori di x .

Come funziona

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

Usa razionali e il metodo di Newton.

Provalo online!

05AB1E , 23 byte

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

Provalo online!

Porta diretta di /codegolf//a/126822/59376 di xnor.

Carbone , 28 byte

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

Provalo online! Collegamento alla modalità dettagliata. Anche a quanto pare ho incasinato Dividee IntDivide: |
Utilizza lo stesso metodo delle risposte Python e JavaScript.

NewStack , 14 byte

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

Abbattersi:

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

Come funziona:

La formula (2x ³ +1) / (3x ² -1) deriva dalla semplificazione del metodo di Newton per l'equasione x ³ = x + 1. Puoi trovarlo qui . Ripetendo questo processo un'infinità di volte converge al numero di plastica. Il suo tasso di convergenza è piuttosto rapido di circa 2,6 decimali per iterazione.

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

Alternativa alla sequenza padovana, 27 25 17 byte

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

Abbattersi:

¹                  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 scegliendo una migliore strategia di stampa

-8 byte scegliendo il modo migliore per indicizzare lo stack

Come funziona:

Mentre la sequenza di Padovan continua, il rapporto degli ultimi due elementi converge al numero di plastica.

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

Utilizza la formula iterata di radice cubica. Questo è un po 'più interessante ma più lungo:

(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

Funziona come la risposta in pitone superiore. No è console.logstato incluso perché se si esegue f(x)in console verrà registrato automaticamente.

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

Si aspetta che l'input sia presente nello stack all'avvio del programma, quindi +3 byte per il -vflag.

Provalo online!

Esegue efficacemente una ricerca binaria per restringere il valore di output. L' xaumento aumenta il numero di iterazioni da eseguire.

Modifica: calcolo refactored leggermente per salvare 1 byte, versione precedente:

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

k, 27 byte

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

Provalo online! Questo presuppone numeri interi infiniti (che, purtroppo, non è vero). Usa la sequenza padovana .

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

Usa questa formula ricorsiva .

È interessante notare che codificare il numero e arrotondarlo indica lo stesso conteggio 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

Usa questa formula trigonometrica .

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

Restituisce il risultato come una frazione.

Spiegazione

Usa il metodo di Newton con x iterazioni per trovare la radice del polinomio p ^ 3-p-1 = 0. La formula è x_n = 1- (f (x_ (n-1))) / (f '(x_ (n-1))) e x_0 è un punto di partenza.

La derivata polinomiale è 3p ^ 2-1 e diciamo x_ (n-1) = b / c. Quindi, usando la formula precedente otteniamo che x_n = (2 b ^ 3 + c ^ 3) / (3 b ^ 2 cc ^ 3). Diciamo anche che partiamo da 1, questo accadrà quando x = 2, perché x> 1, ed è un numero intero. Codice identificato e commentato:

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 online

Crea la spirale padovana e stampa il rapporto degli ultimi due numeri.

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

risultati

(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

il modo in cui vedi h (2) dovrebbe essere 1,32 e non 1,33, quindi c'è qualche errore nelle ultime cifre

Quindi ci sarebbe questo di 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)

Usa la formula per risolvere l'equazione di III grado di tipo x ^ 3-3 * p * x-2 * q = 0 nel caso q ^ 2-p ^ 3> = 0 che è m = sqrt (q ^ 2- p ^ 3) e x = (q + m) ^ (1/3) + (qm) ^ (1/3)

Nel nostro caso r ^ 3-r-1 = 0 questo può essere scritto come r ^ 3-3 * (1/3) r-2 * (1/2) = 0 quindi p = 1/3 q = 1/2 m = 1 / 4-1 / 27 = 23/108 x = (0,5 + m) ^ (1/3) + (0,5-m) ^ (1/3)

questo che usa l'iterazione di Newton con il punto iniziale 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)

cambia nella funzione, digita il valore per ottenere un obj di n + 1 cifre dopo il virgola mobile. Alla fine il valore digit () viene assegnato al valore precedente.

Rubino , 35 byte

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

Provalo online!