C++ Program To Print Fibonacci Sequence Up To Nth Term

The Fibonacci sequence is a fascinating mathematical concept where each number is the sum of the two preceding ones. In this article, you will learn how to write a C++ program to generate and print the Fibonacci sequence up to a specified nth term using an efficient iterative approach.

Problem Statement

The challenge is to generate a sequence of numbers where, starting with 0 and 1, each subsequent number is the sum of the previous two. The program needs to accept an integer n as input and then display the Fibonacci sequence up to that nth term. For instance, if n is 7, the output should be the first 7 terms of the sequence.

Example

For an input n = 7, the desired output for the Fibonacci sequence is: 0 1 1 2 3 5 8

Background & Knowledge Prerequisites

To understand and implement this solution effectively, you should have a basic understanding of:

• C++ Variables: Declaring and assigning values to integer variables.
• Input/Output Operations: Using cin to get user input and cout to print output.
• Control Flow Statements: Specifically, if-else for conditional logic and for loops for iteration.

Use Cases or Case Studies

The Fibonacci sequence appears in various fields, including:

• Nature: Patterns in tree branching, leaf arrangements, and spiral growth of shells often follow Fibonacci numbers.
• Computer Science: Used in algorithms like Fibonacci search and data structures such as Fibonacci heaps.
• Financial Markets: Applied in technical analysis for predicting price movements.
• Art and Architecture: The Golden Ratio, derived from Fibonacci numbers, is considered aesthetically pleasing and is used in design.

Solution Approaches

Iterative Approach Using a for Loop

This method is the most straightforward and efficient way to calculate Fibonacci numbers for a given n by repeatedly adding the previous two terms in a loop.

One-line summary: This approach iteratively calculates each Fibonacci number by summing the two preceding numbers, storing only the necessary last two values at any given time.

// Fibonacci Sequence up to Nth Term
#include <iostream>
using namespace std;

int main() {
    // Step 1: Declare variables
    int n;           // Stores the desired number of terms
    int firstTerm = 0;   // Initialize the first Fibonacci term
    int secondTerm = 1;  // Initialize the second Fibonacci term
    int nextTerm;    // To store the sum of the previous two terms

    // Step 2: Prompt user for input
    cout << "Enter the number of terms (n) for Fibonacci sequence: ";
    cin >> n;

    // Step 3: Handle edge cases for n
    if (n < 0) {
        cout << "Please enter a non-negative integer." << endl;
    } else if (n == 0) {
        cout << "Fibonacci sequence up to 0 terms: " << endl;
    } else if (n == 1) {
        cout << "Fibonacci sequence up to 1 term: " << endl;
        cout << firstTerm << " ";
    } else {
        // Step 4: Print the first two terms
        cout << "Fibonacci sequence up to " << n << " terms: " << endl;
        cout << firstTerm << " " << secondTerm << " ";

        // Step 5: Loop to calculate and print subsequent terms
        for (int i = 3; i <= n; ++i) { // Loop starts from the 3rd term
            nextTerm = firstTerm + secondTerm; // Calculate the next term
            cout << nextTerm << " ";          // Print the next term
            firstTerm = secondTerm;            // Update firstTerm to the previous secondTerm
            secondTerm = nextTerm;             // Update secondTerm to the newly calculated nextTerm
        }
        cout << endl; // New line after printing the sequence
    }

    return 0;
}

Run

Sample Output:

Enter the number of terms (n) for Fibonacci sequence: 10
Fibonacci sequence up to 10 terms: 
0 1 1 2 3 5 8 13 21 34

Stepwise explanation for clarity:

1. Variable Declaration: Three integer variables firstTerm, secondTerm, and nextTerm are initialized to 0, 1, and an unassigned state, respectively. n stores the user's input.
2. User Input: The program prompts the user to enter the number of terms n and stores it.
3. Edge Cases:
   • If n is negative, an error message is displayed.

If n is 0, an empty sequence message is shown.

If n is 1, only the firstTerm (0) is printed.

1. Print Initial Terms: For n greater than 1, the first two terms (0 and 1) are printed directly because the loop starts calculating from the third term.
2. Iteration: A for loop runs from i = 3 up to n. In each iteration:
   • nextTerm is calculated by adding firstTerm and secondTerm.

nextTerm is printed.

firstTerm is updated to the value of secondTerm (the previous second term).

secondTerm is updated to the value of nextTerm (the newly calculated term).

This shifting ensures that firstTerm and secondTerm always hold the last two Fibonacci numbers needed for the next calculation.

Conclusion

The iterative approach provides an efficient and clear method for generating the Fibonacci sequence up to a given nth term in C++. By maintaining just two previous terms and updating them within a loop, the program avoids redundant calculations and handles larger n values effectively.

Summary

• The Fibonacci sequence starts with 0 and 1, with each subsequent number being the sum of the two preceding ones.
• The iterative solution uses a for loop to calculate terms sequentially.
• Key variables (firstTerm, secondTerm, nextTerm) are used to store and update the necessary values.
• Edge cases for n (negative, 0, 1) are handled to ensure correct output.
• This approach is efficient for generating the sequence without recursion overhead.