C Program To Print Fibonacci Series Upto N Terms

The Fibonacci series is a fascinating mathematical sequence where each number is the sum of the two preceding ones, starting from 0 and 1. In this article, you will learn how to write a C program to generate and print the Fibonacci series up to a specified number of terms.

Problem Statement

The goal is to write a C program that takes an integer n as input from the user and then prints the first n terms of the Fibonacci sequence. This involves generating numbers in the sequence 0, 1, 1, 2, 3, 5, 8, and so on, until n terms have been displayed.

Example

If the user enters 5, the program should output the first 5 terms of the Fibonacci series:

0, 1, 1, 2, 3

Background & Knowledge Prerequisites

To understand and implement the solutions effectively, readers should have a basic understanding of:

• C Programming Basics: Familiarity with variables, data types (especially int), and basic input/output operations (printf, scanf).
• Loops: Knowledge of for or while loops is crucial for iterating and generating the series.
• Conditional Statements: Understanding if-else for handling edge cases (e.g., n=1 or n=2).

Use Cases or Case Studies

The Fibonacci sequence appears in various fields beyond pure mathematics:

• Nature and Biology: Explains patterns in plant branching, leaf arrangements (phyllotaxis), and spiral growth in shells and pinecones.
• Computer Science and Algorithms: Used in analyzing the efficiency of algorithms, especially in data structures like Fibonacci heaps and in some search algorithms.
• Financial Markets: Sometimes applied in technical analysis to identify potential support and resistance levels using Fibonacci retracement.
• Art and Architecture: The golden ratio, closely related to the Fibonacci sequence, is often used for aesthetically pleasing proportions.
• Music Theory: Can be found in the structure of musical scales and compositions.

Solution Approaches

We will explore two common approaches to generate the Fibonacci series: an iterative method and a recursive method.

Approach 1: Iterative Method Using a Loop

This is the most efficient and straightforward approach for printing a series up to n terms. It uses a loop to calculate each subsequent term.

One-line summary: Calculate Fibonacci terms sequentially using a loop and three variables to store the previous two terms and the next term.

// Fibonacci Series (Iterative)
#include <stdio.h>

int main() {
    int n, i;
    int t1 = 0, t2 = 1;
    int nextTerm;

    // Step 1: Prompt user for the number of terms
    printf("Enter the number of terms: ");
    scanf("%d", &n);

    printf("Fibonacci Series: ");

    // Step 2: Handle edge cases for n = 1 or n = 2
    if (n <= 0) {
        printf("Please enter a positive integer.\\n");
    } else if (n == 1) {
        printf("%d\\n", t1);
    } else {
        // Step 3: Iterate and print the series
        // Print the first two terms outside the loop
        printf("%d, %d", t1, t2);

        // Calculate and print subsequent terms
        for (i = 3; i <= n; ++i) {
            nextTerm = t1 + t2;
            printf(", %d", nextTerm);
            t1 = t2;
            t2 = nextTerm;
        }
        printf("\\n");
    }

    return 0;
}

Run

Sample Output:

Enter the number of terms: 8
Fibonacci Series: 0, 1, 1, 2, 3, 5, 8, 13

Stepwise Explanation:

1. Initialize Variables: t1 is set to 0 (the first Fibonacci number) and t2 is set to 1 (the second Fibonacci number). nextTerm will store the sum.
2. Get Input: The program prompts the user to enter n, the desired number of terms.
3. Handle Edge Cases:

• If n is less than or equal to 0, an error message is printed.
• If n is 1, only t1 (0) is printed.

1. Iterate and Print:

• For n greater than 1, the first two terms (t1 and t2) are printed directly.
• A for loop starts from i = 3 (since the first two terms are already printed) and continues up to n.
• Inside the loop:
• nextTerm is calculated as the sum of t1 and t2.
• nextTerm is printed.
• t1 is updated to the value of t2.
• t2 is updated to the value of nextTerm. This effectively shifts the "window" to the next pair of numbers in the sequence.

Approach 2: Recursive Method

This method defines the Fibonacci sequence based on its recursive nature: F(n) = F(n-1) + F(n-2), with base cases F(0) = 0 and F(1) = 1.

One-line summary: Define a function that calls itself to compute Fibonacci terms based on the mathematical definition.

// Fibonacci Series (Recursive)
#include <stdio.h>

// Function to calculate the nth Fibonacci number
int fibonacci(int num) {
    if (num <= 1) {
        return num;
    } else {
        return fibonacci(num - 1) + fibonacci(num - 2);
    }
}

int main() {
    int n, i;

    // Step 1: Prompt user for the number of terms
    printf("Enter the number of terms: ");
    scanf("%d", &n);

    printf("Fibonacci Series: ");

    // Step 2: Handle invalid input
    if (n < 0) {
        printf("Please enter a non-negative integer.\\n");
    } else {
        // Step 3: Loop and call the recursive function for each term
        for (i = 0; i < n; i++) {
            printf("%d", fibonacci(i));
            if (i < n - 1) { // Print comma for all except the last term
                printf(", ");
            }
        }
        printf("\\n");
    }

    return 0;
}

Run

Sample Output:

Enter the number of terms: 7
Fibonacci Series: 0, 1, 1, 2, 3, 5, 8

Stepwise Explanation:

1. Recursive Function fibonacci(int num):

• Base Cases: If num is 0 or 1, it directly returns num. These are the termination conditions for the recursion.
• Recursive Step: For num greater than 1, it returns the sum of fibonacci(num - 1) and fibonacci(num - 2). This means it calls itself repeatedly until it hits the base cases.

1. main Function:

• Get Input: Prompts the user for n.
• Loop and Print: A for loop runs from i = 0 to n - 1. In each iteration, it calls the fibonacci(i) function to get the i-th Fibonacci number and prints it.
• It adds a comma after each term except the last one for proper formatting.

Comparison of Approaches:

• Iterative (Approach 1):
• Pros: Highly efficient, uses constant extra space (only a few variables), and avoids redundant calculations. This is generally preferred for generating the series up to n terms.
• Cons: May be slightly less intuitive for beginners to grasp the shifting variable logic.
• Recursive (Approach 2):
• Pros: Directly reflects the mathematical definition, making the code appear elegant and concise.
• Cons: Extremely inefficient for large n due to repeated calculations of the same Fibonacci numbers (e.g., fibonacci(5) calls fibonacci(4) and fibonacci(3), but fibonacci(4) also calls fibonacci(3), leading to redundant work). This results in exponential time complexity. It can also lead to stack overflow errors for very large n due to deep recursion.

Conclusion

Generating the Fibonacci series is a classic programming problem that illustrates fundamental concepts like loops and recursion. While both iterative and recursive methods can solve the problem, the iterative approach is significantly more efficient for printing a sequence of n terms, especially as n grows larger, due to its linear time complexity and constant space usage. The recursive method, though elegant, suffers from performance issues due to redundant computations.

Summary

• The Fibonacci series starts with 0 and 1, where each subsequent number is the sum of the two preceding ones.
• Iterative Method: Uses a for or while loop, storing the previous two terms to calculate the next. It is efficient and recommended for generating n terms.
• Recursive Method: Defines F(n) = F(n-1) + F(n-2) with base cases F(0)=0, F(1)=1. While mathematically intuitive, it is computationally inefficient due to redundant calculations.
• Always consider edge cases like n=0, n=1, or negative n for robust programs.
• For printing a series up to n terms, the iterative approach is superior in terms of performance and resource usage.