# Series Program in Java

**Series Program in Java**

The **series program in Java** is written to print the mathematical series such as the Fibonacci series, Pell series, etc. A few of the renowned series are mentioned below.

**Fibonacci series:**0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, …**Pell series:**0, 1, 2, 5, 12, 29, 70, 169, 408, 985, 2378, 5741, 13860, 33461, …**Catalan number series:**1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786, …

**Note:** We have started the Catalan series with the 0^{th }term.

**Triangular number series:**1, 3, 6, 10, 15, 21, 28, 36, 45, 55, 66, 78, 91, 105, …**Square number series:**1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144, 169, 196, …**Cube number series:**1, 8, 27, 64, 125, 216, 343, 512, 729, 1000, 1331, 1728, …

We will discuss each of the series mentioned above. Let’s begin with the Fibonacci series.

**Fibonacci Series**

Fibonacci series is a series whose next term is the summation of the last two terms. The first two terms of the series are 0 and 1. Thus, the third term is the addition of the first and the second term, i.e., 0 + 1 = 1, the fourth term becomes 1 + 1 = 2, and the fifth term becomes 1 + 2 = 3. Similarly, we can easily find the rest of the terms.

**Pell Series**

Pell series is the series whose next term is the addition of the second last term and the twice of the last term. The first two terms of the series are 0 and 1, respectively. Hence, the third term becomes summation of the first term and the twice of the second term, i.e., 0 + 1 * 2= 2, the fourth term is 1 + 2 * 2= 5, and the fifth term is 2 + 5 * 2= 12, and so on. Thus, if we have to find the n^{th }term (T_{n}), we can represent it as:

T_{n }= T_{n - 2} + (T_{n – 1} * 2), where n > 2.

The following Java code uses the above mathematical relation to print the terms of the Pell series.

**Using Java for Loop**

**Filename:** PellSeriesIterative*.*java

public class PellSeriesIterative { public static void main(String argvs[]) { int t1 = 0, t2 = 1; // the first two terms // Defines the number of terms upto which we are printing the Pell series int noOfTerms = 15; System.out.print("The first " + noOfTerms + " terms of Pell series are: \n"); for(int i = 1; i <= noOfTerms; i++) { if( i == 1) // printing the first term { System.out.print(t1 + " "); } else if(i == 2) // printing the second term { System.out.print(t2 + " "); } else // printing the rest of the term { int t3 = t1 + t2 * 2; System.out.print(t3 + " "); // preparing for the next iteration // updating the t1 and t2 variable. t1 = t2; t2 = t3; } } } }

**Output:**

The first 15 terms of Pell series are: 0 1 2 5 12 29 70 169 408 985 2378 5741 13860 33461 80782

**Explanation:** In the above program, the variables t1 and t2 are representing the first two terms of the Pell series. The *noOfTerms *variable is controlling up to which term the Java for-loop is displaying the Pell series. From the 3^{rd }iteration, we are calculating the next term of the Pell series using the mathematical relation defined above the code.

**Using Recursion**

**Filename:** PellSeriesRecursive*.*java

public class PellSeriesRecursive { // Method for finding terms of the Pell Series public static int pellTerms(int n) { if( n <= 1 ) // base case { return n; } // recursively finding the terms return (2 * pellTerms(n - 1)) + pellTerms(n - 2); } public static void main(String argvs[]) { // Defines the number of terms up to which we are printing the Pell series int noOfTerms = 15; System.out.print("The first " + noOfTerms + " terms of Pell series are: \n"); for(int i = 0; i < noOfTerms; i++) { // invoking the method and storing the outcome int term = pellTerms(i); // displaying the terms of the Pell series System.out.print(term + " "); } } }

**Output:**

The first 15 terms of Pell series are: 0 1 2 5 12 29 70 169 408 985 2378 5741 13860 33461 80782

**Explanation:** In the code, the iteration of the Java for-loop depends on the value of the variable *noOfTerms*. In our case, the loop is iterating 15 times (0 to 14). When the value of the loop variable i is 0, we display the first term of the Pell series. For i = 1, we display the second term of the series, and so on. In each iteration, we are invoking the method *pellTerms() *and storing the result. The method *pellTerms() *is finding the (i + 1)^{th }term, recursively, using the mathematical relation defined above.

**Catalan Number Series**

Catalan number series is a series of natural numbers that are used in various interesting problems where counting is required. Using Combination, the series is represented as:

^{ } ^{ 2n}C_{n}, where n >= 0. On further simplification we get,

^{ } ^{ } , where n >= 0 where n >= 0.

Thus, for n = 0, we get:

= = = = 1

For n = 1, we get:

= = = = 1

For n = 2, we get:

= = = = 2

For n = 3, we get:

= = = = 5

Similarly, we can calculate for any value of n.

The following Java program uses the Java for-loop to display the Catalan number series with the help of the above mathematical formula.

**Using Java for-loop**

**Filename:** CatalanSeriersIterative*.*java

public class CatalanSeriesIterative { public static void main(String argvs[]) { // Defines the number of terms upto which we are printing the Catalan series int noOfTerms = 15; System.out.print("The first " + noOfTerms + " terms of Catalan series are: \n"); // We start from 0^{th }term for(int i = 0; i < noOfTerms; i++) { long term = 1; // initialized by 1 for calculating terms of the series // The following for loops is calculating for(int j = i + 2; j <= 2 * i; j++) { // = (n + 2) * (n + 3) * (n +4) * … * 2n term = term * j; } for(int j = 2; j <= i; j++) { // whatever the result we get in the above loop // must be divided by the n! = (1 * 2 * 3 * … * n). term = term / j; } // displaying the terms System.out.print(term + " "); } } }

**Output:**

The first 15 terms of the Catalan series are: 1 1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440

**Explanation:** Similar to the above examples, this time also, the variable *noOfTerms *is controlling the number of terms being displayed on the console. Notice, in the loop, the variable *term* is of type *long*, which is used for displaying the terms of the series. Instead of the variable of type *long,* we cannot use a variable of type *integer* because the numbers are of bigger size when we display the higher terms of the Catalan series. Instead of using a long variable for displaying terms, still, we have to take care of the overflow, i.e., the number can be bigger than the capacity of a long variable. For example, if we have calculated 2n! factorial separately, then for n = 12, we have to calculate 24! which is equal to 620448401733239439360000. Now, this big number is impossible to store in a long variable. Therefore, we have used two for loops of calculating the terms where we are doing the multiplication and division process side by side so that the resultant number does fit in a long variable.

**Using Recursion**

Before writing the code, let us define the recursive formula for calculating the numbers of the Catalan series.

*T(0) = 1 [Base case]*

*And,*

*T(n) =* *T(i)* * T(n - i - 1), for n >= 1*

Thus,

T(1) = T(i) T(1 - i - 1) = T(0) T(1 – 0 - 1) = T(0) T(0) = 1 1 = 1

T(2) = T(i) T(2 - i - 1) = T(0) T(2 - 0 - 1) + T(1) T( 2 - 1 - 1)

= T(0) T(1) + T(1) T(0) = 1 1 + 1 1 = 1 + 1 = 2

Similarly, other terms can also be calculated.

**Filename:** CatalanSeriesRecursive*.*java

public class CatalanSeriesRecursive { // method for calculating the terms Catalan number series public static long catalanNumbers(int n) { if (n <= 1) // base case { return 1; } long catNo = 0; for (int i = 0; i < n; i++) { // recusively calculating the terms of the Catalan number series catNo = catNo + (catalanNumbers(i) * catalanNumbers(n - i - 1)); } // returning the result return catNo; } public static void main(String argvs[]) { // Defines the number of terms up to which we are printing the Catalan series int noOfTerms = 15; System.out.print("The first " + noOfTerms + " terms of Catalan series are: \n"); // We start from 0th term for(int i = 0; i < noOfTerms; i++) { // calling the method catalanNumbers() and storing the result long term = catalanNumbers(i); // displaying the terms System.out.print(term + " "); } } }

**Output:**

The first 15 terms of Catalan series are: 1 1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440

**Explanation:** For each term, starting from the 0^{th }term, we are invoking the method *catalnNumbers()*, and recursively finding the term of the Catalan series. The recursion used in the code is based on the recursive formula, which we have defined above.

### Application of Catalan Numbers

Catalan numbers are used in many interesting problems where counting is required. A few of them are mentioned below.

- Count the number expressions where n pair of braces are correctly matched.
- For n = 1, valid expression is (). Thus, the count is 1.

- For n = 2, valid expressions are () (), (()). Thus, the count is 2.

- For n = 3, valid expressions are () () (), (()) (), () (()), (() ()), ((())), Thus the count is 5.

- Count the number of different Binary Search Trees for n nodes.
- For n = 2, there are 2 different Binary Search Trees. The following diagram demonstrates the same.

- For n = 3, there are 5 different Binary Search Trees. Observe the following diagram.

### Triangular Number Series

Triangular number series is a series of numbers in triangular pattern. A triangular number is a number that counts the number of objects arranged in an equilateral triangle. Thus, the n^{th }triangular number is the equilateral triangle who’s each side is comprised of n dots/ circle. The following diagram represents the same.

The n^{th }triangular number is also the sum of natural numbers from 1 to n. Mathematically, the n^{th }triangular number is represented by *T(n) = (n* * (n + 1)) / 2.* Thus, T(1) = (1 (1 + 1)) / 2 = (1 2) / 2 = 2 / 2 = 1

T(2) = (2 (2 + 1)) / 2 = (2 3) / 2 = 6 / 2 = 3

T(3) = (3 (3 + 1)) / 2 = (3 4) / 2 = 12 / 2 = 6

Similarly, other triangular numbers can also be calculated. Now, let us observe the code for generating the triangular numbers.

**Using Java for-loop**

**Filename:** TriangularSeriesIterative*.*java

public class TriangularSeriesIterative { public static void main(String argvs[]) { // Defines the number of terms up to which we are printing the Triangular series int noOfTerms = 20; System.out.print("The first " + noOfTerms + " terms of the Triangular series are: \n"); for(int i = 1; i <= noOfTerms; i++) { // calculating the term int term = (i * (i + 1)) / 2; // displaying the term System.out.print(term + " "); } } }

**Output:**

The first 20 terms of Triangular series are: 1 3 6 10 15 21 28 36 45 55 66 78 91 105 120 136 153 171 190 210

**Explanation:** In the code, we have used Java for-loop for calculating the triangular numbers till the 20^{th }term. In each iteration, we are calculating the triangular number with the help of the mathematical formula define above. Now, let us learn the recursive approach.

**Using Recursion**

**Filename:** TriangularSeriesRecursive*.*java

public class TriangularSeriesRecursive { // method for calculating terms of the given series public static int triangularNo(int n) { // base case if(n <= 1) return n; // recursively calculating the term return n + triangularNo(n - 1); } public static void main(String argvs[]) { // Defines the number of terms up to which we are printing the Triangular series int noOfTerms = 20; System.out.print("The first " + noOfTerms + " terms of the Triangular series are: \n"); for(int i = 1; i <= noOfTerms; i++) { // calculating the term // by invoking the method triangularNo() int term = triangularNo(i); // displaying the term System.out.print(term + " "); } } }

** ****Output:**

The first 20 terms of Triangular series are: 1 3 6 10 15 21 28 36 45 55 66 78 91 105 120 136 153 171 190 210

**Explanation:** In the code, the Java for-loop is iterating 20 times for displaying the first 20 numbers of the triangular series. In each iteration, the method *triangularNo()* is called for calculating the terms of the triangular series. In the method *triangularNo()*, we are recursively calculating the sum of the natural number till the i^{th }term. The i^{th }term is passed as an argument to the method *triangularNo()*. The recursion is based on the fact that the n^{th }triangular number is the sum of the first n natural numbers.

**Square Number Series**

Numbers that are perfect square form the square number series. Mathematically, the terms of the Square number series are represented by,

*T(n) = n ^{2}, where n is the n^{th }term*

Thus, for n = 1

T(1) = 1^{2 }= 1 1 = 1

For n = 2,

T(2) = 2^{2 }= 2 2 = 4

For n = 3,

T(3) = 3^{2 }= 3 3 = 9

For n = 4,

T(4) = 4^{2 }= 4 4 = 16

In the similar way, we can calculate the other terms of the Square series. Let’s observe the code to generate the terms of the triangular series.

**Using Java for-loop**

**Filename:** SquareSeriesIterative*.*java

public class SquareSeriesIterative { public static void main(String argvs[]) { // Defines the number of terms up to which we are printing the Square series int noOfTerms = 20; System.out.print("The first" + noOfTerms + " terms of the Square series are: \n"); for(int i = 1; i <= noOfTerms; i++) { // calculating the term using the formula defined above int term = (i * i); // displaying the term System.out.print(term + " "); } } }

**Output:**

The first 20 terms of the Square series are: 1 4 9 16 25 36 49 64 81 100 121 144 169 196 225 256 289 324 361 400

**Explanation:** In the code, we are printing the first 20 terms of the Square series using the Java for-loop. In the body of the for-loop, we have implemented the mathematical formula defined above.

**Using Recursion**

Let’s define the recursive relation to generated the square numbers. The recursion relation is:

*T(1) = 1 [Base case]*

*And,*

*T(n) = (2* * (n – 1) + 1) + T(n – 1), for n >= 2*

Thus,

T(2) = (2 ( 2 – 1) + 1) + T(2 – 1) = (2 1 + 1) + T(1) = 3 + 1 = 4

T(3) = (2 ( 3 – 1) + 1) + T(3 – 1) = (2 2 + 1) + T(2) = 5 + 4 = 9

T(4) = (2 ( 4 – 1) + 1) + T(4 – 1) = (2 3 + 1) + T(3) = 7 + 9 = 16

The other terms can be calculated in the same way.

**Filename:** SquareSeriesRecursive*.*java

public class SquareSeriesRecursive { // Method for calculating the terms of // the Square series recursively public static int sqrNo(int n) { // handling base case if(n == 1) return 1; // recursively finding the terms return ((2 * (n – 1) + 1) + sqrNo(n – 1)); } public static void main(String argvs[]) { // Defines the number of terms up to which we are printing the Square series int noOfTerms = 20; System.out.print("The first " + noOfTerms + " terms of the Square series are: \n"); for(int i = 1; i <= noOfTerms; i++) { // calculating the terms by calling the method sqrNo() int term = sqrNo(i); // displaying the term System.out.print(term + " "); } } }

**Output:**

The first 20 terms of the Square series are: 1 4 9 16 25 36 49 64 81 100 121 144 169 196 225 256 289 324 361 400

**Explanation:** Similar to the iterative approach, here also, we are printing the first 20 terms of the Square series. In each iteration, we are invoking the method *sqrNo() *and displaying the results generated by the method *sqrNo(). *In the method *sqrNo(), *we are calculating the terms of the Square series using the recursive relation explained above.

**Cube Number Series**

Numbers that are perfect cubes form the Cube number series. Mathematically, the terms of the Cube numbers series are represented by:

*T(n) = n ^{3}, where n is the n^{th }term*

Thus, for n = 1, we have

T(1) = 1^{3 }= 1 1 1 = 1

For n = 2,

T(2) = 2^{3 }= 2 2 2 = 8

For n = 3,

T(3) = 3^{3 }= 3 3 3 = 27

For n = 4,

T(4) = 4^{3 }= 4 4 4 = 64

Similarly, we can easily calculate the other terms of the Cube series.

Now, let’s learn about the program to print the terms of the Cube series. We will start with the iterative approach.

**Using for loop**

**Filename:** CubeSeriesIterative*.*java

public class CubeSeriesIterative { public static void main(String argvs[]) { // Defines the number of terms up to which we are printing the Cube series int noOfTerms = 20; System.out.print("The first " + noOfTerms + " terms of the Cube series are: \n"); for(int i = 1; i <= noOfTerms; i++) { // calculating the term using the formula defined above int term = (i * i * i); // displaying the term System.out.print(term + " "); } } }

**Output:**

The first 20 terms of the Cube series are: 1 8 27 64 125 216 343 512 729 1000 1331 1728 2197 2744 3375 4096 4913 5832 6859 8000

**Explanation:** Similar to the iterative approaches of other series, we are calculating the terms of the Cube series with the help of the mathematical formula defined above. This time also, the Java for-loop iterates 20 times.

Now let’s observe how we can do the same thing using recursion.

**Using Recursion**

Before writing the code, it is important to know about the recursive relation for calculating the terms of the Cube series. The recursive relation is:

*T(1) = 1 [Base case]*

*T(n) = T(n – 1) + 1 + 3* * (n – 1)* * (n - 1)* * 1 + 3* * (n – 1)* * 1* * 1, for n >= 2*

Thus, for n = 2, we get

T(2) = T(2 – 1) + 1 + 3 (2 – 1) (2 – 1) 1 + 3 (2 – 1) 1 1

= T(1) + 1 + 3 1 1 1 + 3 1 1 1 = 1 + 1 + 3 + 3 = 8

For n = 3,

T(3) = T(3 – 1) + 1 + 3 (3 – 1) (3 – 1) 1 + 3 (3 – 1) 1 1

= T(2) + 1 + 3 2 2 1 + 3 2 1 1 = 8 + 1 + 12 + 6 = 27

For n = 4,

T(4) = T(4 – 1) + 1 + 3 (4 – 1) (4 – 1) 1 + 3 (4 – 1) 1 1

= T(3) + 1 + 3 3 3 1 + 3 3 1 1 = 27 + 1 + 27 + 9 = 64

In the same way, we can calculate the other terms of the series very easily.

**Note:** The above recursive relation is derived using the following mathematical identity

(a + 1)^{3 }= a^{3 }+ 1^{3 }+ 3.a^{2}.b + 3.a.b^{2}

The following Java code uses the recursive relation to calculate the terms of the series.

**Filename:** CubeSeriesRecursion*.*java

public class CubeSeriesRecursion { // Method for calculating the terms of the Cube series public static int cubeNo(int n) { // base case if(n == 1) return 1; int num = 0; // contains the final result // recursively calculating the terms and storing the result num = cubeNo(n-1) + 1 + 3 * (n - 1) * (n - 1) * 1 + 3 * (n - 1) * 1 * 1; // returning the final result return num; } public static void main(String argvs[]) { // Defines the number of terms up to which we are printing the Cube series int noOfTerms = 20; System.out.print("The first " + noOfTerms + " terms of the Cube series are: \n"); for(int i = 1; i <= noOfTerms; i++) { // invoking the method cubeNo() // and storing the result int term = cubeNo(i); // displaying the term System.out.print(term + " "); } } }

**Output:**

The first 20 terms of the Cube series are: 1 8 27 64 125 216 343 512 729 1000 1331 1728 2197 2744 3375 4096 4913 5832 6859 8000

**Explanation:** In the code, the Java for-loop is again iterating 20 times, and for each iteration, the method *cubeNo() *is invoked, which takes the loop variable *i *in the argument. For each value of the variable *i, *we are calculating the cube of *i *using the recursive formula defined above.