1000 chiffres de pi en python

J'ai réfléchi à cette question et je ne peux pas la comprendre. Peut-être que vous pouvez m'aider. Le problème est que mon code ne fonctionne pas pour la sortie des 1000 décimales de pi dans la langue de programmation python.

Voici mon code:

def make_pi():
    q, r, t, k, m, x = 1, 0, 1, 1, 3, 3
    while True:
        if 4 * q + r - t < m * t:
            yield m
            q, r, t, k, m, x = (10*q, 10*(r-m*t), t, k, (10*(3*q+r))//t - 10*m, x)
        else:
            q, r, t, k, m, x = (q*k, (2*q+r)*x, t*x, k+1, (q*(7*k+2)+r*x)//(t*x), x+2)

digits = make_pi()
pi_list = []
my_array = []
for i in range(1000):
    my_array.append(str("hello, I'm an element in an array \n" ))
big_string = "".join(my_array)

print "here is a big string:\n %s" % big_string

Je sais que ce code peut être fixé au travail, mais je ne suis pas sûr de ce que pour fixer à...L'instruction print dit ici, c'est une grosse corde et la my_array.append(str("hello, im an element in an array \n)) est juste un bouche-pores pour l'instant. Je sais comment tout le code est utilisé pour le travail, mais comme je l'ai dit avant, je n'arrive pas à la tirer hors de ce code.

source d'informationauteur bobimo | 2012-01-25

  1. 15

    Exécuter ce

    def make_pi():
    q, r, t, k, m, x = 1, 0, 1, 1, 3, 3
    for j in range(1000):
        if 4 * q + r - t < m * t:
            yield m
            q, r, t, k, m, x = 10*q, 10*(r-m*t), t, k, (10*(3*q+r))//t - 10*m, x
        else:
            q, r, t, k, m, x = q*k, (2*q+r)*x, t*x, k+1, (q*(7*k+2)+r*x)//(t*x), x+2


digits = make_pi()
pi_list = []
my_array = []

for i in make_pi():
    my_array.append(str(i))

my_array = my_array[:1] + ['.'] + my_array[1:]
big_string = "".join(my_array)
print "here is a big string:\n %s" % big_string

    Et de lire sur yield opérateur à partir d'ici:
    Que signifie le "rendement" mot-clé le faire en Python?

    Voici la réponse:

    3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679821480865132823066470938446095505822317253594081284811174502841027019385211055596446229489549303819644288109756659334461284756482337
  2. 28

    Si vous ne voulez pas mettre en place votre propre algorithme, vous pouvez utiliser mpmath.

    try:
    # import version included with old SymPy
    from sympy.mpmath import mp
except ImportError:
    # import newer version
    from mpmath import mp
mp.dps = 1000  # set number of digits
print(mp.pi)   # print pi to a thousand places

    Référence

    Mise à jour: Code prend en charge les anciennes et les nouvelles installations de SymPy (voir commentaire).*

  3. 1

    Ici, vous pouvez vérifier si votre programme de sorties correctes 1000 chiffres:
    http://spoj.com/CONSTANT

    Bien sûr, vous pouvez utiliser la commande diff ou tc en tant que bien, mais vous devez copier ces 1000 chiffres à partir de quelque part et il vous suffit d'envoyer votre programme et de vérifier si le score est plus grand que 999.

    Vous pouvez essayer d'imprimer encore plus de chiffres là et donc d'obtenir plus de points. Peut-être que vous auriez plaisir à elle.

  4. 0

    Je ne suis pas familier avec votre algorithme. Est-ce une mise en œuvre de BBP?

    Dans tous les cas, votre make_pi est un générateur. Essayez de l'utiliser dans une boucle for:

    for digit in make_pi():
    print digit

    Noter que cette boucle est infinie: make_pi() jamais jette StopIteration

  5. 0

    Est-ce à faire ce que vous voulez?

    i = 0;
pi_str = ""
for x in make_pi():
    pi_str += str(x)
    i += 1
    if i == 1001:
        break

print "pi= %s.%s" % (pi_str[0],pi_str[1:])
  6. 0

    wallis formule peut obtenir à 3.141592661439964 mais un moyen plus efficace est nécessaire pour résoudre ce problème.

    https://www.youtube.com/watch?v=EZSiQv_G9HM

    and now my code
x = 2
y = 3
summing = 4
for count in range (0,100000000):
    summing *= (x/y)
    x += 2
    summing *= (x/y)
    y += 2
print (summing)
  7. -1

    Ici est une autre façon que j'ai trouvée ici --> Python pi calcul? rapprochant python basé sur les frères Chudnovsky formule pour générer des Pi que j'ai sightly modifié pour mon programme.

    def pifunction():
    numberofdigits = int(input("please enter the number of digits of pi that you want to generate"))
    getcontext().prec = numberofdigits

def calc(n):
    t = Decimal(0)
    pi = Decimal(0)
    deno = Decimal(0)
    k = 0
    for k in range(n):
        t = (Decimal(-1)**k)*(math.factorial(Decimal(6)*k))*(13591409+545140134*k)
        deno = math.factorial(3*k)*(math.factorial(k)**Decimal(3))*(640320**(3*k))
        pi += Decimal(t)/Decimal(deno)
    pi = pi * Decimal(12)/Decimal(640320**Decimal(1.5))
    pi = 1/pi
    return str(pi)
print(calc(1))

    J'espère que cette aide comme vous pouvez générer un certain nombre de chiffres de pi que vous souhaitez générer.