Pi is an irrational number having non-recurring decimal values. We commonly know Pi = 3.14 or Pi = 22/7, but it is just an approximation for our ease. One way to calculate it can be given using Nilkantha’s series. It is given by –
π = 3 + 4 / (2*3*4) – 4 / (4*5*6) + 4 / (6*7*8) – . . .
Approach: On observing the pattern of the denominator it can be seen that for every term except the first one, it contains the multiplication of three consecutive numbers. We can use a variable and increment it by two on every iteration to get the correct term in the denominator. Further notice that this is alternating series i.e. sign of consecutive terms is different.
Follow the steps below to implement the above observations
- Create 3 variables n, Pi, sign
- Initialise Pi = 3, n = 2, sign = 1
- Iterate 0 to 1000000 to calculate for 1000000 terms and greater accuracy:
- At every iteration multiply sign = sign*(-1)
- Calculate Pi = Pi + sign*(4/(n) * (n+1) * (n+2))
- Increment n by 2 at every iteration
- Print the value of Pi
Below is the code to implement the above approach:
C++
// C++ code to implement the above approach#include <bits/stdc++.h>using namespace std;// Function to calculate PIdouble calculatePI(double PI, double n, double sign){ // Add for 1000000 terms for (int i = 0; i <= 1000000; i++) { PI = PI + (sign * (4 / ((n) * (n + 1) * (n + 2)))); // Addition and subtraction // of alternate sequences sign = sign * (-1); // Increment by 2 according to formula n += 2; } // Return the value of Pi return PI;}// Driver codeint main(){ // Initialise sum=3, n=2, and sign=1 double PI = 3, n = 2, sign = 1; // Function call cout << fixed << setprecision(8) << "The approximation of Pi is " << calculatePI(PI, n, sign) << endl; return 0;} |
C
// C code to implement the above approach#include <stdio.h>// Function to calculate PIdouble calculatePI(double PI, double n, double sign){ // Add for 1000000 terms for (int i = 0; i <= 1000000; i++) { PI = PI + (sign * (4 / ((n) * (n + 1) * (n + 2)))); // Addition and subtraction // of alternate sequences sign = sign * (-1); // Increment by 2 according to formula n += 2; } // Return the value of Pi return PI;}// Driver codevoid main(){ // Initialise sum=3, n=2, and sign=1 double PI = 3, n = 2, sign = 1; // Function call printf("The approximation of Pi is %0.8lf\n",calculatePI(PI, n, sign));}// This code is contributed by ashishsingh13122000. |
Java
// JAVA code to implement the above approachimport java.util.*;class GFG {// Function to calculate PIstatic double calculatePI(double PI, double n, double sign){ // Add for 1000000 terms for (int i = 0; i <= 1000000; i++) { PI = PI + (sign * (4 / ((n) * (n + 1) * (n + 2)))); // Addition and subtraction // of alternate sequences sign = sign * (-1); // Increment by 2 according to formula n += 2; } // Return the value of Pi return PI;}// Driver codepublic static void main(String[] args){ // Initialise sum=3, n=2, and sign=1 double PI = 3, n = 2, sign = 1; // Function call System.out.print("The approximation of Pi is "); System.out.printf("%.8f%n", calculatePI(PI, n, sign));}}// This code is contributed by sanjoy_62. |
Python3
import math# Function to calculate PIdef calculatePI(PI,n,sign): # Add for 1000000 terms #for (int i = 0; i <= 1000000; i++) { for i in range(0,1000000): PI = PI + (sign * (4 / ((n) * (n + 1)* (n + 2)))) # Addition and subtraction of alternate sequences sign = sign * (-1) # Increment by 2 according to formula n += 2 # Return the value of Pi return PI# Driver code# Initialise sum=3, n=2, and sign=1PI = 3n = 2sign = 1# Function calla = calculatePI(PI, n, sign)print("The approximation of Pi is ",end="")print(round(a,8));# This code is contributed by ashishsingh13122000 |
C#
// C# code to implement the above approachusing System;class GFG { // Function to calculate PI static double calculatePI(double PI, double n, double sign) { // Add for 1000000 terms for (int i = 0; i <= 1000000; i++) { PI = PI + (sign * (4 / ((n) * (n + 1) * (n + 2)))); // Addition and subtraction // of alternate sequences sign = sign * (-1); // Increment by 2 according to formula n += 2; } // Return the value of Pi return PI; } // Driver code public static void Main() { // Initialise sum=3, n=2, and sign=1 double PI = 3, n = 2, sign = 1; // Function call Console.Write("The approximation of Pi is "); Console.Write(Math.Round(calculatePI(PI, n, sign), 8)); }}// This code is contributed by Samim Hossain Mondal. |
Javascript
<script>// Javascript code to implement the above approach// Function to calculate PIfunction calculatePI( PI , n , sign){ // Add for 1000000 terms for (let i = 0; i <= 1000000; i++) { PI = PI + (sign * (4 / ((n) * (n + 1) * (n + 2)))); // Addition and subtraction // of alternate sequences sign = sign * (-1); // Increment by 2 according to formula n += 2; } // Return the value of Pi document.write("The approximation of Pi is " + PI);}// Driver code// Initialise sum=3, n=2, and sign=1let PI = 3, n = 2, sign = 1;// Function callcalculatePI(PI, n, sign);</script> |
Output
The approximation of Pi is 3.14159265
Time Complexity: O(N * logN * loglogN), Where N is the number of iterations
Auxiliary Space: O(1)
Feeling lost in the world of random DSA topics, wasting time without progress? It’s time for a change! Join our DSA course, where we’ll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 neveropen!
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 neveropen!
