Fibonacci Series in Java [Case-Study Based]

# Fibonacci Series in Java [Case-Study Based]

Atul Harsha
Senior Manager Content
Updated on Jul 26, 2023 18:09 IST

The Fibonacci series is a sequence of numbers in which each number is the sum of the two preceding ones, usually starting with 0 and 1. In Java, the Fibonacci series can be implemented using loops, recursion, or a combination of both.

Problem: Write a Java program that generates the first n numbers in the Fibonacci series, starting with 0 and 1. The Fibonacci series is a sequence of numbers in which each number is the sum of the previous two numbers in the series.

For example, the first 10 numbers in the Fibonacci series are: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34

Input: An integer n (1 <= n <= 50), which represents the number of numbers to generate in the Fibonacci series.
Output: fib(10) => [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

Fibonacci Series Program in C++
The Fibonacci series is an intriguing mathematical idea that is popular for practicing in Python, especially for those just starting out.
Fibonacci Series in Python
Fibonacci Series is a sequence of numbers where each number is the sum of the two previous numbers. This article will discuss the Fibonacci Series, How to Create a Fibonacci...read more
Fibonacci Program in C
The Fibonacci Series is a sequence of numbers where each number is a sum of the previous two numbers. This article will explore how to implement the Fibonacci Series in...read more

## Solution 1: Fibonacci Series in Java using for loop

• If n is 0, return 0.
• Initialize the variables previous and current to 0 and 1, respectively. Initialize the variable next to 0.
• Start a loop that iterates n – 1 times.
• In each iteration of the loop:
• Calculate the next value in the sequence as the sum of previous and current.
• Update previous to the value of current.
• Update current to the value of next.
• Return the value of current.

CODE:

` `
```class Fibonacci { public int fib(int n) { // base case: if n is 0, return 0 if (n == 0) { return 0; } // initialize the previous, current, and next values int previous = 0; int current = 1; int next = 0; // loop through the remaining values of the sequence for (int i = 1; i < n; i++) { // calculate the next value in the sequence next = previous + current; // update the previous and current values previous = current; current = next; } // return the current value return current; }}Copy code```

## Solution 2: Fibonacci Series in Java using while loop

` `
```public class Fibonacci { public static void main(String[] args) { // initialize the first two values of the series int previous = 0; int current = 1; // print the first two values System.out.print(previous + " " + current + " "); // initialize the next value in the series int next = 0; // loop through the remaining values of the series while (next < 100) { // calculate the next value in the series next = previous + current; // print the next value System.out.print(next + " "); // update the previous and current values previous = current; current = next; } }}Copy code```

The code initializes the first two values of the Fibonacci series (0 and 1) and prints them. It then initializes a variable next to 0 and enters a while loop. While loop executes till next is less than 100.

• Inside the while loop, the code:
• Calculates the next value in the series by adding the previous and current values and stores it in the next variable.
• Prints the value of next.
• Updates the previous and current values to the current values of current and next, respectively.
• The loop continues this process until the value of next becomes greater than or equal to 100, at which point the loop will exit.

## Solution 3: Fibonacci Series in Java without using loop

` `
`class Fibonacci { public int fib(int n) { // base case: if n is 0, return 0 if (n == 0) { return 0; } // base case: if n is 1, return 1 else if (n == 1) { return 1; } // recursive case: if n is greater than 1, // return the sum of the previous two numbers in the sequence else { return fib(n - 1) + fib(n - 2); } }}Copy code`

This version of the code uses recursion to calculate the nth Fibonacci number. The recursion stops when n is 0 or 1, and the Fibonacci number is returned directly. For all other values of n, the function calls itself with n – 1 and n – 2 as arguments, and returns the sum of the two returned values.

## Maximizing Field Area with the Fibonacci Series: A Case Study for Efficient Fencing

Problem: A farmer wants to fence off a rectangular field using the least amount of fencing material possible. The field is bordered by a river on one side, so the farmer only needs to fence the other three sides. The farmer has a roll of fencing material that can be used to build the fence, and the roll has a fixed length.

The farmer wants to build the fence in such a way that the area of the field is maximized, given the fixed length of the fencing material. Use the Fibonacci series to determine the optimal dimensions of the field, because the ratio of the length to the width of the field will approach the golden ratio (approximately 1.618) as the length and width get larger.

Write a Java program that calculates the maximum possible area of the field, given the fixed length of the fencing material and the desired number of terms in the Fibonacci series to use.

Input:

• An integer n (1 <= n <= 50), which represents the number of terms in the Fibonacci series to use.
• An integer L (1000 <= L <= 10000), which represents the length of the fencing material in meters.

Output:

• An integer, representing the maximum possible area of the field in square meters.

### Solution:

` `
```public class FieldFencing { public static void main(String[] args) { int n = 10; // number of terms in the Fibonacci series int L = 5000; // length of fencing material in meters // initialize the previous and current values of the Fibonacci series int prev = 1; int current = 1; int next = 0; // loop through the remaining terms of the Fibonacci series for (int i = 2; i < n; i++) { // calculate the next term in the series next = prev + current; // update the previous and current values prev = current; current = next; } // calculate the maximum possible area of the field int width = L / current; int length = L - width; int area = width * length; System.out.println("Maximum possible area of the field: " + area + " square meters"); }}Copy code```

This program generates the first n terms in the Fibonacci series. It calculates the maximum possible area of the field by dividing the length of the fencing material by the nth term in the series. The width of the field is equal to this value, and the length of the field is equal to the remaining fencing material. The area of the field is then calculated as the product of the width and length.

## FAQs

What is Fibonacci Series?

Fibonacci numbers are the sequence of numbers defined by the linear equation, F(n) = F(n-1) + F(n-2), for n = 3, 4, ... and F(0) = 0, F(1) = F(2) = 1.

What are the first 10 Fibonacci Numbers in the Fibonacci Series?

The first 10 Fibonacci numbers are, 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55.

What is the use of Fibonacci Series?

Fibonacci Series is used in Finance (Stock Market Analysis), Computer Science (Efficient Search), Music ( Tuning Musical Instruments), Art (Creating Pleasing Visual Design).