Le défi

Le nombre plastique est un nombre lié au nombre d'or, avec de nombreuses propriétés mathématiques intéressantes. En tant que tel, il existe de nombreuses approches qui peuvent être utilisées pour calculer le nombre.

Afin de spécifier précisément le nombre aux fins de ce défi, nous utiliserons la définition suivante (bien qu'il existe de nombreuses définitions équivalentes, et vous pouvez utiliser n'importe quelle définition de votre choix tant qu'il s'agit du même nombre):

Le nombre plastique est un nombre réel ρ tel que ρ ³ = ρ +1.

Votre défi consiste à écrire un programme ou une fonction qui prend un entier x en entrée (avec x > 1), et produit une approximation de ρ en sortie, de sorte que plus la valeur de x est grande, plus la sortie se rapproche de ρ ( avec au maximum un nombre infini d'exceptions; rester à la même valeur compte comme "plus proche" à cet effet), et pour tout nombre positif δ , il y a une entrée x dans votre programme qui produit une sortie qui est à moins de δ de ρ .

Clarifications

• Si vous effectuez une sortie via une méthode qui génère de manière inhérente des chaînes (par exemple le flux de sortie standard), vous pouvez formater la sortie soit en décimal (par exemple 1.3247179572), soit comme un rapport de deux entiers avec un /caractère entre eux.
• Si vous générez une valeur dans votre langage de programmation (par exemple, en revenant d'une fonction), elle doit être de type à virgule fixe, à virgule flottante ou rationnelle. (En particulier, vous ne pouvez pas utiliser des types de données qui stockent des nombres symboliquement, à moins qu'ils ne soient utilisés que pour maintenir le rapport de deux entiers. Donc, si vous utilisez Mathematica ou un langage similaire, vous devrez inclure le supplément pour générer réellement les chiffres de la sortie.)
• Votre réponse doit fonctionner dans une variante hypothétique de votre langue dans laquelle les entiers peuvent être arbitrairement grands et la mémoire (y compris la pile) est illimitée. Vous ne pouvez pas supposer que l'arithmétique à virgule flottante dans votre langue est arbitrairement précise, mais devez plutôt utiliser sa précision réelle (ce qui signifie que la sortie d'un nombre à virgule flottante ne sera possible que dans les langues où la précision des nombres à virgule flottante peut être contrôlé à l'exécution).
• x peut avoir la signification que vous voulez (tant que l'augmentation donne des sorties plus précises). J'imagine que la plupart des soumissions le feront contrôler le nombre de chiffres de sortie à produire, ou le nombre d'itérations de l'algorithme utilisé par votre programme pour converger sur le nombre plastique, mais d'autres significations sont acceptables.

Cas de test

Voici les premiers chiffres du numéro en plastique:

1.32471795724474602596090885

Plus de chiffres sont disponibles sur OEIS .

Condition de victoire

Comme d'habitude pour le code-golf , plus court est meilleur, mesuré en octets. Cependant, n'hésitez pas à publier des réponses même si elles ne gagnent pas, tant qu'elles ajoutent quelque chose (par exemple une langue différente ou un algorithme différent) aux réponses existantes.

Python 2 , 49 octets

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

Essayez-le en ligne!

L'idée est d'exprimer le ρavec ρ³=ρ+1comme une fraction n/xdont le dénominateur xest le paramètre de précision d'entrée. Nous prenons (n/x)³=n/x+1et dégageons les dénominateurs à obtenir n³=x²(x+n).

Étant donné que le LHS augmente nplus rapidement que le RHS, nous pouvons approximer le point d'égalité ncomme le plus petit avec n³≥x²(x+n). Le code compte njusqu'à ce que ce soit le cas, à partir xduquel il est plus petit.

Un petit octet de sauvegarde consiste à diviser les deux côtés en x²écriture n³/x²≥x+n(annulé dans la whilecondition). Il s'agit de la division du plancher dans le code, mais la partie fractionnelle perdue est négligeable.

Une alternative de même longueur met xà la place comme numérateur:

Python 2 , 49 octets

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

Essayez-le en ligne!

Mathematica, 20 octets

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

La Rootfonction intégrée de Mathematica donne les solutions d'une équation polynomiale f[x] == 0.

Explication

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

Exemple d'E / S

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 octets

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

-1 octet de Martin
-2 octets de ovs

contribution

[27]

sortie

{1.32471795724474602596090885}

sed , 67 60 (59 + 1) octets

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

Essayez-le en ligne!

+1 pour le -Edrapeau (ERE au lieu de BRE). L'entrée et la sortie sont toutes les deux unaires: entrée 11111 pour x = 5, par exemple, la sortie est une fraction de deux nombres unaires: l'entrée 11111 susmentionnée donne la sortie 11111/1111 (5/4 en décimal).

Approximation du nombre de plastique sous forme de fraction entre les éléments consécutifs de la séquence Padovan .

Mathematica, 27 octets

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

Utilise une approximation tronquée de la forme du radical cubique imbriqué ³√ (1 + ³√ (1 + ³√ (1 + ...))) . Bien que la sortie contienne toujours x-1 décimales, le résultat est en fait moins précis que cela, car l'expression converge plus lentement qu'un chiffre par itération ( x est également utilisé comme nombre de radicaux imbriqués calculés). Par exemple, x = 100 donne

_________________________________________________________________________
1.324717957244746025960908854478097340734404056901733364534015050302827850993693624204577670741656151

où la partie soulignée est correcte.

Octave , 50 octets

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

Essayez-le en ligne!

Définit une fonction anonyme, avec nle nombre souhaité de chiffres de sortie.

Cette réponse abuse qui digitsrenvoie le paramètre actuel pour le nombre de chiffres dans l'arithmétique à précision variable. Cela signifie que nous pouvons simplement l'utiliser dans une fonction anonyme sans erreur sur «Trop d'arguments de sortie».

En dehors de cela, c'est vraiment simple: vpasolveest l'abréviation de Résolution arithmétique à précision variable, avec la précision définie par le dernier appel de digits. Comme il vpas'agit d'un type de données symbolique dans Octave, qui est interdit par la spécification, nous enveloppons simplement la fonction entière char(...)pour obtenir une sortie de chaîne. Notez que dans solveet vpasolve, le f==0est implicite, a donc r^3==r+1été remplacé parr^3-r-1 (==0)

MATL ( 27 28 octets)

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

Ma première solution (27 octets)

Essayez-le en ligne!

Ce n'est certainement pas optimal, je m'habitue toujours à MATL.

Explication:

Je crée une séquence Padovan jusqu'à l'entrée + 3 puis trouve le rapport des deux derniers nombres.

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 ρ

Sortie de fraction appropriée (35 octets) (28 octets, @Sanchises):

Cependant, la première solution ne répond pas au besoin de précision arbitraire étant la limite à virgule flottante des paramètres MATL par défaut. Ainsi, plutôt que d'ajouter plusieurs octets pour étendre cette précision, il est plus simple de prendre la route de fraction appropriée et d'écrire une fraction des deux derniers nombres entiers dans les (N-1) ^ème et N ^ème éléments de la séquence Padovan tronquée.

par exemple "114/86"

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

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

Avec l'aimable autorisation de l'utilisateur @Sanchises. :)

Essayez-le en ligne!

Évaluation non itérative:

Notamment, mon code le plus court pour la version «exacte» est (23 octets):

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

Essayez-le en ligne!

... mais ne donne pas de précision arbitraire. Je me demande si quelqu'un peut ajuster cela pour respecter les règles (utiliser l'entrée, etc.) et ajouter encore moins de 5 octets? : P

M , 15 14 octets

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

Essayez-le en ligne!

Algorithme

Cela utilise des rationnels et la méthode de Newton. Plus précisément, pour l'entrée x , les premières x itérations avec la valeur de départ x sont appliquées.

Nous essayons de trouver une racine spécifique du polynôme p (t) = t³ - t - 1 . La méthode de Newton y parvient en prenant une valeur de départ t ₀ - suffisamment proche de ρ - et en définissant récursivement une séquence par
t _{n + 1} = t _n - p (t _n ) / p '(t _n ) .

Puisque p '(t) = 3t² -1 , on obtient
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) .

Notez que l'approximation initiale x s'aggrave progressivement à mesure que x augmente. Alors que la sortie pour x = 3 est légèrement moins précise que la sortie pour x = 2 , puisque la méthode de Newton converge de façon quadratique vers ρ , cela ne devrait pas être un problème pour les grandes valeurs de x .

Comment ça marche

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

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

Utilise les logiques et la méthode de Newton.

Essayez-le en ligne!

05AB1E , 23 octets

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

Essayez-le en ligne!

Port direct de /codegolf//a/126822/59376 par xnor.

Fusain , 28 octets

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

Essayez-le en ligne! Lien vers le mode verbeux. J'ai aussi apparemment foiré Divideet IntDivide: |
Utilise la même méthode que les réponses Python et JavaScript.

NewStack , 14 octets

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

Panne:

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

Comment ça marche:

La formule (2x ³ +1) / (3x ² -1) provient de la simplification de la méthode de Newton pour l'équasion x ³ = x + 1. Vous pouvez le trouver ici . Répéter ce processus une infinité de fois converge vers le nombre plastique. Son taux de convergence est plutôt rapide à environ 2,6 décimales par itération.

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

Alternative à la séquence Padovan, 27 25 17 octets

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

Panne:

¹                  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 octets en choisissant une meilleure stratégie d'impression

-8 octets en choisissant une meilleure façon d'indexer la pile

Comment ça marche:

Au fur et à mesure que la séquence de Padovan se poursuit, le rapport des deux derniers éléments converge vers le nombre de plastique.

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

Clojure, 46 octets

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

Utilise la formule itérée de racine cubique. C'est un peu plus intéressant mais plus long:

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

((f 10)1)
1.3247179361449652

Javascript, 36 octets

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

Fonctionne de la même manière que la réponse python supérieure. Non console.logétait inclus car si vous exécutez f(x)dans la console, il sera enregistré automatiquement.

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

> <> , 38 + 3 = 41 octets

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

Attend que l'entrée soit présente sur la pile au démarrage du programme, donc +3 octets pour l' -vindicateur.

Essayez-le en ligne!

Effectue efficacement une recherche binaire pour affiner la valeur de sortie. L' xaugmentation augmente le nombre d'itérations à effectuer.

Edit: calcul légèrement refactorisé pour économiser 1 octet, version précédente:

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

k, 27 octets

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

Essayez-le en ligne! Cela suppose des nombres infinis (ce qui, hélas, n'est pas vrai). Il utilise la séquence Padovan .

TI-BASIC, 21 octets

: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

Utilise cette formule récursive .

Fait intéressant, coder en dur le nombre et l'arrondir donne le même nombre d'octets:

TI-BASIC, 21 octets

: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

Utilise cette formule trigonométrique .

C # , 317 octets

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

Il renvoie le résultat sous forme de fraction.

Explication

Il utilise la méthode de Newton avec x itérations pour trouver la racine du polynôme p ^ 3-p-1 = 0. La formule est x_n = 1- (f (x_ (n-1))) / (f '(x_ (n-1))), et x_0 est un point de départ.

La dérivée des polynômes est 3p ^ 2-1, et disons x_ (n-1) = b / c. Ensuite, en utilisant la formule ci-dessus, nous obtenons que x_n = (2 b ^ 3 + c ^ 3) / (3 b ^ 2 cc ^ 3). Disons également que nous partons de 1, cela se produira lorsque x = 2, car x> 1, et est un entier. Code identifié et commenté:

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 octets

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

Crée la spirale de Padovan et imprime le rapport des deux derniers nombres.

Axiome, 96 octets

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

résultats

(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

comment vous pouvez voir h (2) devrait être 1,32 et non 1,33, donc il y a une erreur dans les derniers chiffres

Ensuite, il y aurait celui de 110 octets

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)

Il utilise la formule pour résoudre l'équation de grade III de type x ^ 3-3 * p * x-2 * q = 0 dans le cas q ^ 2-p ^ 3> = 0 qui est m = sqrt (q ^ 2- p ^ 3) et x = (q + m) ^ (1/3) + (qm) ^ (1/3)

Dans notre cas r ^ 3-r-1 = 0, cela peut être écrit comme r ^ 3-3 * (1/3) r-2 * (1/2) = 0 donc p = 1/3 q = 1/2 m = 1 / 4-1 / 27 = 23/108 x = (0,5 + m) ^ (1/3) + (0,5-m) ^ (1/3)

celui-ci qui utilise l'itération de Newton avec le point de départ 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)

il change dans la fonction, valeur des chiffres pour obtenir un obj de n + 1 chiffres après le point flottant. À la fin, la valeur digits () est affectée à la valeur précédente.

Rubis , 35 octets

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

Essayez-le en ligne!