What is the 49th decimal digit of pi ?

Question

Its 9 right.
And I have coded it, it was a project in "Code Coach" to find the decimal digit of pi.

https://www.sololearn.com/compiler-playground/cx0BfO65098k

import math

x = str(math.pi)
y = len(x)
n = []
m = []
num = len(x) - 1
o = len(x) - 1

for i in range(y) :
n.append(x[num])
num -= 1

for i in range(y) :
m.append(n[o])
o -= 1

m.remove(m[0])
m.remove(m[0])

x1 = int(input())
y1 = m * x1

x1 -= 1
print(y1[x1])

But the project says that I have only passed 3 tests and 2 other tests still fails.
I dont know what have I done wrong.

Any help will be appreciated.

Answer 1

Part 2

The easiest way to solve this problem is to copy pi up to 1000 digits as a string constant into your code, and use indexing to find the required Nth digit. You can get over a 1000-digit (or character) pi from here: https://www.piday.org/million/

Another way is to use some algorithm to numerically approximate pi. There are many algos, with some being more effective (faster to calculate) than others:
https://en.m.wikipedia.org/wiki/Approximations_of_%CF%80#Development_of_efficient_formulae

However using an algo won't make a difference if we're still calculating pi on a float type. We need to use a type which is both accurate and can store many digits. Python's built-in `decimal` module has the `Decimal` type (among other things), which addresses this issue and can be used to solve our problem: https://docs.python.org/3/library/decimal.html

To approximate pi to any precision, you can use the 'Decimal' type, with an implemented algo yourself or use the pi function in the 'recipes' section of the docs.

Answer 2

Engineer X I recommend to check how other people solved this problem.
If you navigate to the code playground, you can search for "calculate pi" and you will find a lot of codes in various languages and using various techniques.

Each of these solutions is a practical implementation of a mathematical proof that was described in some research paper.
In programming it is hard to deal with infinity and irrational numbers and we typically use approximation and margins of error, to arrive at an acceptable precision. It depends on the algorithm, how quickly we converge to this solution, and it depends on the number of iterations, how close we can get. We could continue the calculations forever to get an infinite number of PI digits :)

Answer 3

Hi Tibor Santa ,
Thanks for the advice, I founded a code and now I have to see how the code works.

Answer 4

Hi @Mozzy ,
Thanks for the guidance, it helped me a lot.

I think at first I should learn about decimals (which i did just now and it was amazing) and how to code an algorithm.
Then maybe I should be able to solve this project.

By the way, thanks a lot for all the people who helped me in this project.

Answer 5

Can you post the task description please?

Answer 6

Part 1

I'll be splitting my explanation into a few parts because of the char limit and because this code coach problem requires some understanding of the nature of pi and how computers store fixed point numbers.

The actual decimal representation of pi isn't a finite number - the digits go on forever. Also, the digits go on without ever repeating in a fixed way, meaning there's no pattern to them. This is why the part of your code that repeats the pi digits yields incorrect results.

The standard python implemention defines float as a 64-bit floating point type, which can hold very large or very small numbers, but with a precision of around 15-16 digits. Since `math.pi` is a float type, it is only precise to 16 digits max. For most problems involving pi, this constant is enough, but since this problem involves finding up to the 1000th digit of pi and since we can't just repeat the digits, we can't use it.

Your approach however, is partly right - represent pi as a string and use indexing to find a digit.

Answer 7

If you use python you can cheat a little by importing some tools from sympy and get pi's digits to very high precision.

https://docs.sympy.org/latest/modules/evalf.html

But to solve it the hard way you need to use some algorithm to approximate the value and it cannot be stored as a floating point number.

Answer 8

Hi Mozzy ,

Thanks for the answer.

Btw, the first way is easy and I could do that but about the second way.
I saw all those algorithms and all of them were too hard for me, I mean I have never calculated such things before and putting them into my code is sth unimaginable to me.

I have also never used decimal module before and I dont know how to use it.

How can I put an algorithm into my code and how can I use decimal module?

If you could post a code, that would help a lot.

Thank you

Answer 9

Aside from the official documentation, there are plenty of online tutorials on the decimal module. Only basic understanding is needed for this problem - Decimal object and 'context'. Here are some guides that I used:
https://www.pythonforbeginners.com/basics/decimal-module-in-JUMP_LINK__&&__python__&&__JUMP_LINK
https://m.youtube.com/watch?v=2ZcqUXcb90k

Coding the pi algorithms can be tricky. Don't be discouraged though, it just requires some work and patience. You also don't really need to understand the deep math behind it. Some time ago I've manage to (naively) implement the Chudnovsky algorithm, which is one of the fastest algos today. My code was almost entirely based off the Wiki page: https://en.m.wikipedia.org/wiki/Chudnovsky_algorithm

The code isn't optimzed for the sake of clarity. I just followed it step-by-step from the wiki page, using Decimal objects for values and a `for` loop to run the summation. Most of the other infinite series algos can be implemented in this way.
https://code.sololearn.com/c6dBcFQun1jq/?ref=app

Answer 10

Hi Ausgrindtube ,

The constant Pi is defined as the ratio of a circle's circumference to its diameter.
Pi is an irrational number, meaning that it's digits never end or repeat in any known way.

Task:
Given an integer N as input, find and output the Nth decimal digit of Pi.

Input Format:
An integer: 0<N<1000

Output Format:
An integer, representing the Nth decimal digit of Pi.

Sample Input:
12

Sample Output:
9