Best 5 Programs on Fibonacci Series in C

Introduction

The Fibonacci series is a fascinating mathematical sequence that has captured the interest of mathematicians and programmers alike. In this article, we will explore the best 5 programs in the C programming language to generate the Fibonacci series.

Also Read: C Program to Store and Display Data of 100 Books

Whether you are a beginner looking to understand the basics or an experienced programmer seeking efficient algorithms, this article will provide you with valuable insights and code examples.

So let’s dive in and unravel the mysteries of the Fibonacci series!

Program 1: Recursive Approach

The recursive approach is one of the simplest ways to generate the Fibonacci series in C. The program uses a recursive function to calculate the nth Fibonacci number.

Here’s an example of the recursive program:

Also Read: Leap Year Program in C: Simplifying the Logic

#include <stdio.h>

int fibonacci(int n)
{
    if (n <= 1)
        return n;
    
    return fibonacci(n - 1) + fibonacci(n - 2);
}

int main()
{
    int i, n = 10;

    printf("Fibonacci Series: ");
    for (i = 0; i < n; i++)
    {
        printf("%d ", fibonacci(i));
    }
    
    return 0;
}

In this program, the fibonacci function takes an integer n as input and recursively calculates the nth Fibonacci number.

The main function calls this function for each index i from 0 to n-1 and prints the series.

Also Read: C Program to Find the Longest Line in a File

Program 2: Iterative Approach

The iterative approach is another efficient method to generate the Fibonacci series in C. It avoids redundant calculations by using a loop to calculate and update the values of the series.

Here’s an example of the iterative program:

#include <stdio.h>

void fibonacciSeries(int n)
{
    int i, first = 0, second = 1, next;

    printf("Fibonacci Series: ");
    for (i = 0; i < n; i++)
    {
        printf("%d ", first);
        next = first + second;
        first = second;
        second = next;
    }
}

int main()
{
    int n = 10;
    
    fibonacciSeries(n);
    
    return 0;
}

In this program, we initialize first and second as the first two numbers of the series.

We then use a loop to calculate the subsequent numbers by updating the values of first and second. The series is printed as the loop progresses.

Also Read: C Program to Find the Inverse of 2×2 Matrix

Program 3: Array Approach

The array approach provides an efficient way to generate the Fibonacci series by storing the calculated values in an array.

This approach avoids redundant calculations and improves performance.

Here’s an example of the array-based program:

#include <stdio.h>

void fibonacciSeries(int n)
{
    int i, fib[n];
    fib[0] = 0;
    fib[1] = 1;

    printf("Fibonacci Series: ");
    printf("%d %d ", fib[0], fib[1]);

    for (i = 2; i < n; i++)
    {
        fib[i] = fib[i - 1] + fib[i - 2];
        printf("%d ", fib[i]);
    }
}

int main()
{
    int n = 10;
    
    fibonacciSeries(n);
    
    return 0;
}

In this program, we declare an array fib to store the Fibonacci series. We initialize the first two elements as 0 and 1, respectively.

Then, using a loop, we calculate and store the subsequent numbers in the array. The series is printed as the loop progresses.

Also Read: C Program to Copy the Contents of One File into Another File

Program 4: Matrix Exponentiation

The Fibonacci series can also be generated efficiently using matrix exponentiation.

This approach has a time complexity of O(log(n)) and is particularly useful when dealing with large values of n.

Here’s an example of the matrix exponentiation program:

#include <stdio.h>

void multiply(int F[2][2], int M[2][2])
{
    int x = F[0][0] * M[0][0] + F[0][1] * M[1][0];
    int y = F[0][0] * M[0][1] + F[0][1] * M[1][1];
    int z = F[1][0] * M[0][0] + F[1][1] * M[1][0];
    int w = F[1][0] * M[0][1] + F[1][1] * M[1][1];

    F[0][0] = x;
    F[0][1] = y;
    F[1][0] = z;
    F[1][1] = w;
}

void power(int F[2][2], int n)
{
    int i;
    int M[2][2] = {{1, 1}, {1, 0}};

    for (i = 2; i <= n; i++)
        multiply(F, M);
}

int fibonacci(int n)
{
    int F[2][2] = {{1, 1}, {1, 0}};

    if (n == 0)
        return 0;
    
    power(F, n - 1);
    
    return F[0][0];
}

int main()
{
    int i, n = 10;

    printf("Fibonacci Series: ");
    for (i = 0; i < n; i++)
    {
        printf("%d ", fibonacci(i));
    }
    
    return 0;
}

In this program, we use matrix exponentiation to calculate the Fibonacci numbers.

The multiply function performs the multiplication of two matrices, and the power function raises a given matrix to the power of n.

The fibonacci function calculates the nth Fibonacci number using these operations. The series is then printed using a loop.

Also Read: Switch Case in C Program to Calculate Area of Circle and Triangle

Program 5: Golden Ratio Formula

The Golden Ratio is closely related to the Fibonacci series.

We can use the Golden Ratio formula to calculate Fibonacci numbers. Here’s an example of the program:

#include <stdio.h>
#include <math.h>

int fibonacci(int n)
{
    double phi = (1 + sqrt(5)) / 2;
    return round(pow(phi, n) / sqrt(5));
}

int main()
{
    int i, n = 10;

    printf("Fibonacci Series: ");
    for (i = 0; i < n; i++)
    {
        printf("%d ", fibonacci(i));
    }
    
    return 0;
}

In this program, we utilize the Golden Ratio (phi) formula to calculate the Fibonacci numbers.

We raise phi to the power of n and divide it by the square root of 5. The result is rounded to the nearest integer using the round function. The series is then printed using a loop.

Also Read: Getchar and Putchar Function in C with Example

FAQs

Also Read: 25 Tricky Questions on Pointers in C: Explained and Answered

Conclusion

In this article, we explored the best 5 programs on the Fibonacci series in the C programming language.

We covered various approaches, including recursive, iterative, array-based, matrix exponentiation, and the use of the Golden Ratio formula.

Each approach has its advantages and considerations depending on the value of n and the desired efficiency.

By understanding these programs, you can gain valuable insights into the Fibonacci series and its applications.

So go ahead and apply this knowledge in your programming endeavors!