Itérations de Bailey – Borwein – Plouffe
Nous avons vu quelques défis pi sur PPCG, mais aucun qui dicte spécifiquement l'algorithme que vous devez utiliser. J'aimerais voir des implémentations de l' algorithme Bailey – Borwein – Plouffe dans n'importe quel langage jusqu'à l'itération n. La formule est la suivante:
Votre algorithme doit sortir chaque itération jusqu'à n, en montrant les sommes intermédiaires ainsi que le résultat final pour former un "piangle". Vous pouvez également utiliser la forme polynomiale réduite de l'algorithme présenté sur la page wikipedia. Un exemple d'exécution pour n=50est illustré ci-dessous:
3
3.1
3.14
3.141
3.1415
3.14159
3.141592
3.1415926
3.14159265
3.141592653
3.1415926535
3.14159265358
3.141592653589
3.1415926535897
3.14159265358979
3.141592653589793
3.1415926535897932
3.14159265358979323
3.141592653589793238
3.1415926535897932384
3.14159265358979323846
3.141592653589793238462
3.1415926535897932384626
3.14159265358979323846264
3.141592653589793238462643
3.1415926535897932384626433
3.14159265358979323846264338
3.141592653589793238462643383
3.1415926535897932384626433832
3.14159265358979323846264338327
3.141592653589793238462643383279
3.1415926535897932384626433832795
3.14159265358979323846264338327950
3.141592653589793238462643383279502
3.1415926535897932384626433832795028
3.14159265358979323846264338327950288
3.141592653589793238462643383279502884
3.1415926535897932384626433832795028841
3.14159265358979323846264338327950288419
3.141592653589793238462643383279502884197
3.1415926535897932384626433832795028841971
3.14159265358979323846264338327950288419716
3.141592653589793238462643383279502884197169
3.1415926535897932384626433832795028841971693
3.14159265358979323846264338327950288419716939
3.141592653589793238462643383279502884197169399
3.1415926535897932384626433832795028841971693993
3.14159265358979323846264338327950288419716939937
3.141592653589793238462643383279502884197169399375
3.1415926535897932384626433832795028841971693993751
3.14159265358979323846264338327950288419716939937510
La précision de chaque itération doit être égale à la n qui est passée à l'algorithme, c'est-à-dire que chaque itération doit calculer pi jusqu'au passé npour tous k.
Règles:
- Les fonctions intégrées ne sont pas autorisées, ni
pivous ne devez pas non plus utiliser la formule. - Vous devez soutenir
njusqu'à un maximum que votre langue permet en termes de calcul16^n. Si l'entrée provoque un dépassement arithmétique pendant le calcul après lesx<nexécutions parce que votre langue ne prend en charge que les décimales jusqu'à2^32-1, cela ne pose aucun problème . Toutes les autres hypothèses surnne sont pas correctes. - Vous DEVEZ fournir une explication de la façon dont vous avez obtenu la sortie si ce n'est pas évident. Par exemple, si vous publiez dans une langue de golf, une ventilation est requise à 100%. C'est pour vous assurer que vous utilisez l'algorithme spécifié.
- Les trous de boucle standard ne sont pas autorisés.
- Il s'agit du code-golf, le nombre d'octets le plus bas gagne ici.
Code de référence (code utilisé pour générer l'exemple):
public static void main(String[] args) {
(0..50).each {
n->
def x=(0..n).collect {
j->
def k=new BigDecimal(j)
def s={it.setScale(n)}
def a=s(1.0g).divide(s(16.0g)**s(k))
def b=s(4.0g)/(s(8.0g)*s(k)+s(1.0g))
def c=s(2.0g)/(s(8.0g)*s(k)+s(4.0g))
def d=s(1.0g)/(s(8.0g)*s(k)+s(5.0g))
def e=s(1.0g)/(s(8.0g)*s(k)+s(6.0g))
def f=a*(b-c-d-e)
}.sum()
println(n + "\t" + x.setScale(n, BigDecimal.ROUND_DOWN))
}
}
Cette mise en œuvre plafonne à n=255, vous pouvez plafonner à moins ou plus.
Cette implémentation a été effectuée dans Groovy.
Calculate foo via x methoddéfis.Réponses:
05AB1E ,
635250 octetsFormule de spécialisation
Essayez-le en ligne!
Formule BBP
Essayez-le en ligne!
la source
Python 2,
109108 octetsTestez-le sur Ideone .
la source
Python 2, 174 octets
Man, c'est un moment où je souhaite que Python ait un moyen plus facile de garder une précision infinie pour les décimales. La formule est écrite textuellement.
Exemple de sortie pour
n=100(avec quelques numéros de ligne ajoutés):Cela semble fonctionner pour un plus grand nombre,
n=1000s'exécute en quelques secondes etn=10000ne semble pas encore m'avoir donné d'erreurs!la source
Haskell,
101100octetsMerci à @nimi pour un octet.
Mise en œuvre simple. Calcule
njusqu'à 15 chiffres (double précision standard).la source
l<-[8*fromIntegral k]au lieu de l'let ...enregistre un octet.J,
736462 octetsCela renvoie chaque approximation à n chiffres sous forme de chaîne formatée. Cela utilise la simplification polynomiale de la formule et obtient le premier n chiffres en multipliant la somme par une puissance de 10, en l'étalant et en divisant par cette même puissance de 10.
L'entrée est considérée comme un entier étendu, ce qui signifie que les rationnels sont utilisés lorsque la division se produit, ce qui maintient les résultats exacts.
Usage
Il s'agit de la sortie pour n = 100, montrant les sommes cumulées pour k dans [0, 100].
Explication
Faites d'abord la plage [0, n ], indiquée pour n = 5
Multipliez chacun par 8
Former le tableau d'addition entre
[1, 4, 5, 6]et les produits avec 8Divisez chaque ligne par
[4, 2, -1, 1]Ensuite, réduisez les colonnes de bas en haut en utilisant la soustraction
Divisez chaque 16 k pour k en [0, n ] par chaque résultat
Trouver les sommes cumulées
Calculez 10 k pour k dans [0, n ] et multipliez-le avec chacun
Ensuite, étage chacun des produits
Divisez-le par la même puissance de 10 pour obtenir les résultats
la source
PARI / GP, 86 octets
Ou sans le point décimal en 69 octets :
Plutôt que de diviser par 16 k à chaque itération, la valeur précédente de p est plutôt multipliée par 16 . Le plancher de p ÷ (8/5) k est alors la valeur de π tronquée au nombre correct de chiffres.
Exemple d'utilisation
la source
C GCC, 118 octets
Golfé:
Non golfé:
Pour changer n, il suffit de changer while (k <15) en while (k <n)
production:
la précision maximale est de 15 décimales, je pourrais augmenter à n'importe quelle valeur avec gmp, mais peut-être le lendemain pi: P
avec jolie impression, 143 octets
Golfé:
Non golfé:
production:
la source
Formule IBM / Lotus Notes, 125 octets
Formule dans un champ calculé avec un autre champ appelé "a" pour la saisie.
Fondamentalement, un port de l'algorithme de la réponse Python de @shebang. Calcule jusqu'à 15 chiffres, après quoi il tronque en raison d'une limitation de la langue (voir sortie). J'ai dû gaspiller 12 octets avec la déclaration @If à la fin juste pour se débarrasser de la. après le 3 au départ: - /
Non golfé
la source
C #, 183 octets
Golfé:
Non golfé:
la source
3.14159265358979de tout enn >= 14raison de la double précision?APL (NARS), 206 caractères, 412 octets
Cela permet de trouver toutes les approssimations en grand rationnel, puis d'utiliser une fonction qui convertit le grand rationnel en chaîne numérique ... test:
la source