Generating Fibonacci Series using Recursion: C Program

Write a recursive function to obtain the first 25 numbers of a Fibonacci sequence. In a Fibonacci sequence the sum of two successive terms gives the third term. Following are the first few terms of the Fibonacci sequence:

1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89 …

Note: In this video tutorial we’ve taken 0 and 1 as the first 2 numbers in the Fibonacci series- they’re called Seed Values. And we ask the user to enter the limit or the number of terms to be printed in the Fibonacci Series.

At the end of this article you can find C program source code which exactly matches the above problem statement. So if you’re only looking for exact solution to above problem statement, then directly scroll down to the end of this article and you can get the source code for it.

Related Read:
C Program To Generate Fibonacci Series using For Loop
Recursive Functions In C Programming Language

What Is Fibonacci Series?

Fibonacci Series is a series of numbers where the first two Fibonacci numbers are 0 and 1, and each subsequent number is the sum of the previous two. Its recurrence relation is given by Fn = Fn-1 + Fn-2.

Below we have series of Fibonacci numbers(10 terms):
0
1
1
2
3
5
8
13
21
34

How Its Formed:
0 <– First Number (n1)
1 <– Second Number (n2)
1 <– = 1 + 0 (1 and 0 are previous 2 terms)
2 <– = 1 + 1
3 <– = 2 + 1
5 <– = 3 + 2
8 <– = 5 + 3
13 <– = 8 + 5
21 <– = 13 + 8
34 <– = 21 + 13

Video Tutorial: Generating Fibonacci Series using Recursion: C Program


[youtube https://www.youtube.com/watch?v=cyi7QLlc_aE]

YouTube Link: https://www.youtube.com/watch?v=cyi7QLlc_aE [Watch the Video In Full Screen.]


Source Code: C Program To Generate Fibonacci Series using Recursive Function

#include<stdio.h>

int fib(int);

int main()
{
    int limit, count;

    printf("Enter no of terms of Fibonacci Series to be printed\n");
    scanf("%d", &limit);

    for(count = 1; count <= limit; count++)
    {
        printf("\n%d. %d\n", count, fib(count));
    }

    return 0;
}

int fib(int num)
{
    if(num == 1)
        return(0);
    else if(num == 2 || num == 3)
        return(1);
    else
        return( fib(num-1) + fib(num-2) );
}

Output:
Enter no of terms of Fibonacci Series to be printed
8

1. 0

2. 1

3. 1

4. 2

5. 3

6. 5

7. 8

8. 13

Logic To Generate Fibonacci Series using For Loop

We ask the user to enter the limit or the number of terms he or she wants to print or display in the Fibonacci series. We store the user input number in a variable called limit.

We initialize the loop counter variable count to 1. Now we iterate the for loop from 1 to user input limit times. For each iteration we call the function fib() and pass the value present in the variable count. fib(count) gets the Fibonacci number for the count or nth term.

Inside fib() function
We know the first two terms in the Fibonacci series which are 0 and 1. To get the third term in this series we add 0 and 1. So the next term is 0+1 which is 1 once again. We’ll write separate conditions for this inside the fib() function.

If num is 1, we return 0. Which is the first term in the series. If num is 2 or 3, we return 1. Because 1 is the third as well as forth term in the series. If num is neither 1, nor 2 or 3, then we call the same function( fib() ) and pass the immediate preview 2 terms of the Fibonacci Series which are (num – 1) and (num -2), and add it to get the next term in the series.

fib(num-1) + fib(num-2)

This equation will keep calling itself and ultimately reduce to fib(1) or fib(2) or fib(3) for which we already know the values.

Example:

If user inputs a value of 5 to limit, then we need to print 5 terms in the Fibonacci Series. We write a for loop and iterate the loop from 1 to limit times. For each iteration of the for loop, loop counter value increments by 1. Inside for loop we call fin() method and pass the value present inside loop counter variable count. Through out the life cycle of the for loop, count will have value from 1 to 5. i.e., 1, 2, 3, 4, 5

For each iteration following code will be executed, and the returned value is printed out to the console window.

num or count fib() Output
1fib(1)0
2fib(2)1
3fib(3)1
4fib(4) = fib(3) + fib(2) 2
5fib(5) = fib(4) + fib(3) 3

For fifth iteration fib(5) = fib(4) + fib(3) which follows the recurrence relation formula F(n) = F(n-1) + F(n-2).

Here fib(4) can be reduced to:
fib(4) = fib(4-1) + fib(4-2)
fib(4) = fib(3) + fib(2)

Now replace the value of fib(4) in below equation:

fib(5) = [fib(4)] + fib(3);
fib(5) = [fib(3) + fib(2)] + fib(3);

We already know that fib(2) and fib(3) are both equal to 1.

fib(5) = [1 + 1] + 1;
fib(5) = 2 + 1;
fib(5) = 3;

So the fifth term in the Fibonacci series is 3.

Source Code: Exact Solution For Above Problem Statement

#include<stdio.h>

int fib(int);

int main()
{
    int limit = 25, count;

    for(count = 1; count <= limit; count++)
    {
        printf("\n%d. %d\n", count, fib(count));
    }

    return 0;
}

int fib(int num)
{
    if(num == 1 || num == 2)
        return(1);
    else
        return( fib(num-1) + fib(num-2) );
}

Output:
1. 1

2. 1

3. 2

4. 3

5. 5

6. 8

7. 13

8. 21

9. 34

10. 55

11. 89

12. 144

13. 233

14. 377

15. 610

16. 987

17. 1597

18. 2584

19. 4181

20. 6765

21. 10946

22. 17711

23. 28657

24. 46368

25. 75025

Source Code: Generate 25 terms in Fibonacci Series using Recursion and Ternary/conditional operator

#include<stdio.h>

int fib(int);

int main()
{
    int limit = 25, count;

    for(count = 1; count <= limit; count++)
    {
        printf("\n%d. %d\n", count, fib(count));
    }

    return 0;
}

int fib(int num)
{
    return( (num == 1 || num == 2) ? 1 : ( fib(num-1) + fib(num-2) ) );
}

Output:
We get the same 25 terms in Fibonacci series as with above source code. Know more about ternary operator or conditional operator in a separate video tutorial: Ternary Operator / Conditional Operator In C

Disadvantages of using Recursion

Recursive Calls are not always efficient. Particularly in calculating Fibonacci Series – It’s better to use the regular iterative ways, instead of recursion. Recursion in this program creates lot of overhead for memory stack.

C Program To Generate Fibonacci Series using For Loop

Practice this program only as a way to learn the logic and working of recursion in C program.

For list of all c programming interviews / viva question and answers visit: C Programming Interview / Viva Q&A List

For full C programming language free video tutorial list visit:C Programming: Beginner To Advance To Expert

C Program To Calculate Sum of Digits Using Recursion

A 5-digit positive integer is entered through the keyboard, write a recursive and a non-recursive function to calculate sum of digits of the 5-digit number.

Analyze The Problem Statement

1. User enters a 5-digit number.
2. We need to write 2 functions to calculate sum of digits of user entered number.
3. One function should use recursive logic and the other should calculate sum of digits without using recursion.

Related Read:
Recursive Functions In C Programming Language
Calculate Sum of Digits: C Program

Video Tutorial: C Program To Calculate Sum of Digits Using Recursion


[youtube https://www.youtube.com/watch?v=tPbkgtSoG4Y]

YouTube Link: https://www.youtube.com/watch?v=tPbkgtSoG4Y [Watch the Video In Full Screen.]


Source Code: C Program To Calculate Sum of Digits Using Recursion

#include<stdio.h>

int add(int);
int add_rec(int);

int main()
{
    int num;

    printf("Enter a 5-digit positive integer number\n");
    scanf("%d", &num);

    printf("Sum of Digits(without using recursion): %d\n", add(num));
    printf("Sum of Digits(using recursion): %d\n", add_rec(num));

    return 0;
}

int add(int num)
{
    int sum = 0;

    while(num)
    {
        sum = sum + (num % 10);
        num = num / 10;
    }

    return(sum);
}

int add_rec(int num)
{
    if(num)
        return( (num % 10) + add_rec(num / 10) );
    else
        return 0;
}

Output 1:
Enter a 5-digit positive integer number
12345
Sum of Digits(without using recursion): 15
Sum of Digits(using recursion): 15

Output 2:
Enter a 5-digit positive integer number
15937
Sum of Digits(without using recursion): 25
Sum of Digits(using recursion): 25

Logic To Calculate Sum of Digits without using Recursion

1. Using (num % 10), we fetch the last digit of the user entered number and add it to the previous value of sum.
2. Next we reduce the uer entered number by 1 digit(from the right end) by dividing the number by 10 i.e., num / 10.
3. We put above two steps/logic into while loop. We iterate through the while loop until num is positive. Once num value is 0, control exits the while loop.
4. Outside while loop we return the value present in variable sum – which will have the sum of all the individual digits of the user entered number.
If num = 12345;

numnum%10sumnum/10
12345551234
123449123
12331212
122141
11150

If you observe above table, when num becomes 0, sum has 15 in it. So 15 is the sum of all the individual digits of the user entered number 12345.

i.e., 1 + 2 + 3 + 4 + 5 = 15.

Full logic with separate video explaining this concept is present at Calculate Sum of Digits: C Program. Kindly watch it without fail.

Logic To Calculate Sum of Digits using Recursion

If num is positive we execute below line of code

return( (num % 10) + add_rec(num / 10) );

If num is 0, then we return zero.

Recursive Function Calls – Stacking of calls

Call Fromnum % 10add_rec(num / 10)
add_rec(12345)5add_rec(1234)
add_rec(1234)4add_rec(123)
add_rec(123)3add_rec(12)
add_rec(12)2add_rec(1)
add_rec(1)1add_rec(0)

Value Returning – Control Shifting back.

Return To(num % 10) + resultReturn value
add_rec(0)return(0)0
add_rec(1)1 + add_rec(0)1 + 0 = 1
add_rec(12)2 + add_rec(1)2 + 1 = 3
add_rec(123)3 + add_rec(12)3 + 3 = 6
add_rec(1234)4 + add_rec(123)4 + 6 = 10
add_rec(12345)5 + add_rec(1234)5 + 10 = 15

So at the end 15 is returned back to main() method and the result is printed on the console window.

Note: Whenever there is a call to a function, the function instance(and memory associated with it) gets stored in the memory stack. Once the function returns value to calling function, the control shifts back to the calling function and the memory instance gets popped out of the memory stack immediately after returning the value.

Ternary or Conditional Operator And Recursion

int add_rec(int num)  
{  
    return( ( num > 0 ) ? ( (num % 10) + add_rec(num / 10) ) :  0 );

}  

You can even write the recursive logic to find sum of digits of a number using above ternary or conditional operator.

Source Code: C Program To Calculate Sum of Digits Using Recursion And Ternary Operator

#include<stdio.h>

int add(int);
int add_rec(int);

int main()
{
    int num;

    printf("Enter a 5-digit positive integer number\n");
    scanf("%d", &num);

    printf("Sum of Digits(without using recursion): %d\n", add(num));
    printf("Sum of Digits(using recursion): %d\n", add_rec(num));

    return 0;
}

int add(int num)
{
    int sum = 0;

    while(num)
    {
        sum = sum + (num % 10);
        num = num / 10;
    }

    return(sum);
}

int add_rec(int num)
{
    return( ( num > 0 ) ? ( (num % 10) + add_rec(num / 10) ) :  0 );
}

Output 1:
Enter a 5-digit positive integer number
12345
Sum of Digits(without using recursion): 15
Sum of Digits(using recursion): 15

Output 2:
Enter a 5-digit positive integer number
98654
Sum of Digits(without using recursion): 32
Sum of Digits(using recursion): 32

You can know more about Ternary or Conditional Operators in this video tutorial Ternary Operator / Conditional Operator In C.

For list of all c programming interviews / viva question and answers visit: C Programming Interview / Viva Q&A List

For full C programming language free video tutorial list visit:C Programming: Beginner To Advance To Expert

Recursive Functions In C Programming Language

Lets learn recursive functions in C programming language, with examples and illustrations of memory and function instances in the stack.

Stake is a Data Structure and we’ll be discussing it once we start teaching Data Structures using C topics. For now consider it as a memory stack and some organized structure to hold data, which follows LIFO rule. i.e., Last In, First Out

That is, the last instance which enters the stack is the one which leaves the stack first.

Related Read:
Function / Methods In C Programming Language

Recursive Function: A function calling itself, within it’s own function definition is called Recursive Function.

Types of Recursive Functions

There are 4 types of recursive functions:
1. Direct Recursive function.
2. In-direct Recursive function.
3. Tail Recursive function.
4. Non-tail Recursive function.

We’ll discuss each one in separate video tutorials.

In this video tutorial lets learn the very basic of how to write and use recursive functions and how to keep track of function instances and return data.

Requirements To Learn Recursion

1. You need to know basics of C programming language. If you’re a total beginner, then we do not advice you to start with recursive functions. Just go to this page C Programming: Beginner To Advance To Expert and start watching the C program video tutorials one by one, and in no time you’ll be an advance user and you can learn/understand Recursive functions.

2. If you know the basics, then grab a piece of paper and get a pen. Write down the program on the paper, and also write the function call instances and track the variable values. Write everything we’re explaining in this video tutorial. If you get any doubts, write it down too. Watch the video once again and check if your doubts are cleared. If its still not cleared, follow the next step.

3. Turn on your computer and your favorite C editor, and type the program. Don’t copy paste it. Write the code yourself. Better if you write it without looking at the source code we’ve posted below. Once you execute and get the results, edit/modify the source code and check for different results. Check if you can edit the program and clarify your doubts. If you still don’t understand, then use the comment section below and ask your doubts.

4. Even if you understood the concept well, please visit the comment section below and try to help other students understand it. By teaching, you learn more.

Video Tutorial: Recursive Functions In C Programming Language


[youtube https://www.youtube.com/watch?v=tUQw_ty97yQ]

YouTube Link: https://www.youtube.com/watch?v=tUQw_ty97yQ [Watch the Video In Full Screen.]


Source Code: Recursive Functions In C Programming Language: Example

#include<stdio.h>

void natural(int);

int main()
{
    int num = 1;

    natural(num);

    return 0;
}

void natural(int num)
{
    if(num <= 3)
    {
        natural(num+1);
        printf("%d  ", num);
    }

    return;
}

Output:
3 2 1

Logic To Print natural numbers from 1 to 3 using Recursion

We call natural() function and pass num to it. Initial value of num is set to 1. Inside natural() function/method we check if the value of num is less than or equal to 3. If true, we call the method natural() and pass num+1 to it. Once num is greater than 3, return statement executes and the control transfers to the calling function and the remaining code in that function gets executed. In our program we have printf statement after the recursive function call. So our program prints the value of num and then transfers the control to the calling function.

SlnonumFunction Call
11main()
21nature(1+1)
32nature(2+1)
43nature(3+1)
54nature(4+1)

Each time the recursive call is executed, an instance of the function and memory associated with it is pushed or added to the stack. And for each time the return statement is executed, the function and the memory associated with it is popped or deleted from the stack.

Stack is a Data Structure used to store data in some organized way. For now just know that its a memory stack in your RAM. It’s like a basket which holds the data in particular order. The data is stored one upon another. So the one which gets inserted or pushed at the last is the one which gets popped out first. This concept is called LIFO. Which means, Last In, First Out.

5
4
3
2
1

So we have 5 numbers inside the stack. If we want to add 6 to it, it’ll sit at the top of 5. In above stack, if you want to pop out, the first number you can pop out is the last number present in the stack, which is 5. You can only pop out the items one by one in this order, from above stack: 5, 4, 3, 2, 1.

For list of all c programming interviews / viva question and answers visit: C Programming Interview / Viva Q&A List

For full C programming language free video tutorial list visit:C Programming: Beginner To Advance To Expert

C Program To Find GCD using Repeated Subtraction

Lets write a C program to find Greatest Common Divisor of two positive integer numbers using repeated subtraction.

Related Read:
C Program to Find GCD or HCF of Two Numbers
C Program To Find GCD and LCM of Two Numbers using Euclidean algorithm
C Program To Find GCD using Pointers and Functions

Video Tutorial: C Program To Find GCD using Repeated Subtraction


[youtube https://www.youtube.com/watch?v=sv8Jehsydrs]

YouTube Link: https://www.youtube.com/watch?v=sv8Jehsydrs [Watch the Video In Full Screen.]


Source Code: C Program To Find GCD using Repeated Subtraction

#include<stdio.h>

int main()
{
    int num1, num2;

    printf("Enter 2 positive integer numbers\n");
    scanf("%d%d", &num1, &num2);

    num1 = (num1 < 0) ? -num1 : num1;
    num2 = (num2 < 0) ? -num2 : num2;

    printf("\nGreatest Common Divisor of %d and %d is ", num1, num2);

    while(num1 != num2)
    {
        if(num1 > num2)
        {
            num1 = num1 - num2;
        }
        else
        {
            num2 = num2 - num1;
        }
    }

    printf("%d.\n", num1);

    return 0;
}

Output 1:
Enter 2 positive integer numbers
20
30

Greatest Common Divisor of 20 and 30 is 10.

Output 2:
Enter 2 positive integer numbers
1980
1617

Greatest Common Divisor of 1980 and 1617 is 33.

Logic To Find GCD using Repeated Subtraction

Lets assume that num1 = 15 and num2 = 20. Lets calculate GCD for these 2 numbers.

While loop iterates until num1 is equal to num2.

num1num2Greater NoSubtract NumbersResult
1520num2 = 20num2 =
num2 – num1
num2:
20 – 15 = 5
155num1 = 15num1 =
num1 – num2
num1:
15- 5 = 10
105num1 = 10num1 =
num1 – num2
num1:
10- 5 = 5
55Both Are Equalnum1 == num2GCD is 5.

You can see below code in the C program i.e., converting a negative number into positive. Our source code above works only for positive integer numbers without this code. If the user enters negative value we use ternary operator to make it a positive value.

    num1 = (num1 < 0) ? -num1 : num1;  
    num2 = (num2 < 0) ? -num2 : num2;  

Here we check if num1 is less than 0. If true, then value of num1 is negative. So we multiply the number by -, which gives us a positive number. For example, if num1 is -15, then -(-15) is +15.

Ternary Operator / Conditional Operator In C

You can make use of simple if else statement like below, to convert negative number into positive:

#include<stdio.h>
if(num1 < 0)
   num1 = num1 * -1;

if(num2 < 0)
   num2 = num2 * -1;

That would convert a negative number to positive number.

While Loop
While loop iterates until num1 is not equal to num2. Once num1 is equal to num2, control exits while loop. Whatever is present in num1 or num2 is the GCD of 2 positive integer numbers entered by the user.

Inside while loop, we check if num1 is greater than num2. If true, we subtract num2 from num1 and store it back inside variable num1. Else if num2 is greater than num1, then we subtract num1 from num2 and store it back inside num2. We repeat this until num1 is equal to num2.

For list of all c programming interviews / viva question and answers visit: C Programming Interview / Viva Q&A List

For full C programming language free video tutorial list visit:C Programming: Beginner To Advance To Expert

C Program To Find GCD using Pointers and Functions

Write a function to compute the greatest common divisor given by Euclid’s algorithm, exemplified for J = 1980, K = 1617 as follows:

1980 / 1617 = 11980 – 1 * 1617 = 363
1617 / 363 = 41617 – 4 * 363 = 165
363 / 165 = 2363 – 2 * 165 = 33
5 / 33 = 5165 – 5 * 33 = 0

Thus, the greatest common divisor is 33.

Analyze Above Problem Statement

1. We need to find Greatest Common Divisor(GCD) of 2 numbers entered by the user, using Euclid’s Algorithm.

2. If J = 1980 and K = 1617, GCD should be 33.

3. Make sure to use the calculation part as shown in problem statement.

4. We observe the calculation part in problem statement and formulate some formulas to figure out the result i.e., GCD of 2 numbers input by the user.

Related Read:
C Program To Find GCD and LCM of Two Numbers using Euclidean algorithm

Video Tutorial: C Program To Find GCD using Pointers and Functions, using Euclid’s Algorithm


[youtube https://www.youtube.com/watch?v=mwDUeKUURbM]

YouTube Link: https://www.youtube.com/watch?v=mwDUeKUURbM [Watch the Video In Full Screen.]


Source Code: C Program To Find GCD using Pointers and Functions, using Euclid’s Algorithm

#include<stdio.h>

void calc_gcd(int, int, int*);

int main()
{
    int j, k, gcd;

    printf("Enter 2 integer numbers\n");
    scanf("%d%d", &j, &k);

    calc_gcd(j, k, &gcd);

    printf("\nGreatest Common Divisor of %d and %d is %d.\n", j, k, gcd);

    return 0;
}

void calc_gcd(int numerator, int denominator, int *gcd)
{
    int temp, num;

    if(denominator == 0)
    {
        *gcd = numerator;
    }
    else if(numerator == 0)
    {
        *gcd = denominator;
    }
    else
    {
        num  = numerator / denominator;
        temp = numerator - num * denominator;

        while(temp)
        {
            numerator   = denominator;
            denominator = temp;
            num  = numerator / denominator;
            temp = numerator - num * denominator;
        }

        *gcd = denominator;
    }
}

Output 1:
Enter 2 integer numbers
1980
1617

Greatest Common Divisor of 1980 and 1617 is 33.

Output 2:
Enter 2 integer numbers
1617
1980

Greatest Common Divisor of 1617 and 1980 is 33.

Output 3:
Enter 2 integer numbers
15
20

Greatest Common Divisor of 15 and 20 is 5.

Output 4:
Enter 2 integer numbers
20
15

Greatest Common Divisor of 20 and 15 is 5.

Logic To Find GCD using Pointers and Functions, using Euclid’s Algorithm

We ask the user to input integer values for variables j and k. We pass values of j and k and address of variable gcd to a function called calc_gcd().

Inside calc_gcd() function
Inside calc_gcd() function we use the following calculations:

Note: We copy the value of j, k and &gcd passed by main method into local variables of calc_gcd() i.e., numerator, denominator and *gcd.

Step 1: We check if denominator is 0. In that case the value present in numerator itself is the GCD. So we copy value present in variable numerator to *gcd.

Step 2: If denominator is not zero. Then, we divide numerator with denominator value and store the result into a variable called num.

num = numerator / denominator;

If j = 1980 and k = 1617, then numerator = 1980 and denominator = 1617.

num = numerator / denominator;
num = 1980/ 1617;
num = 1;

According to problem statement:

1980 / 1617 = 11980 – 1 * 1617 = 363

We’ve formulated the equation for the first part i.e., 1980 / 1617 = 1
Now lets formulate an equation for the second part i.e., 1980 – 1 * 1617 = 363

If you look at 1980 – 1 * 1617 = 363 closely and substitute the values with corresponding variables then you’ll come up with below formula:

temp = numerator – num * denominator;

Look at Step 1 for values of numerator, denominator and num.

Now lets look at the equations given in the problem statement:

1980 / 1617 = 11980 – 1 * 1617 = 363
1617 / 363 = 41617 – 4 * 363 = 165

In this look at 1617 / 363 = 4. Here the value of denominator has been shifted to numerators place, and the value of temp has been copied to denominator. So lets write the code:

numerator = denominator;
denominator = temp;

Step 3: Now lets use these formulate in co-ordination to finish writing our function code.

We need to repeat the code in order to get the results according to the columns present in the problem statement equations:

Here are our formulas:

   
        num         = numerator / denominator;
        temp        = numerator - num * denominator;     
        numerator   = denominator;
        denominator = temp;

Here are the steps in problem statement to calculate the GCD:

1980 / 1617 = 11980 – 1 * 1617 = 363
1617 / 363 = 41617 – 4 * 363 = 165
363 / 165 = 2363 – 2 * 165 = 33
5 / 33 = 5165 – 5 * 33 = 0

We need to repeat execution of our code to get above result:

num  = numerator / denominator;
temp = numerator - num * denominator;

     while(temp)
     {
        numerator   = denominator;
        denominator = temp;
        num  = numerator / denominator;
        temp = numerator - num * denominator;
      }

      *gcd = denominator;

We need to put our code inside a looping construct to repeat the code. Here we are using while loop. So while loop iterates until temp value is positive. Once value of temp is 0, the control exits the while loop.

We have written 2 lines of code before the while loop:

num  = numerator / denominator;
temp = numerator - num * denominator;

that is because we need to have some value inside variable temp before using it as condition for while loop.

Once the value of temp is 0, control exits while loop. Outside while loop we transfer the value present inside denominator to *gcd.

So *gcd will have the Greatest Common Divisor for values input by the user(j = 1980 and k = 1617).

Observe this table from problem statement

1980 / 1617 = 11980 – 1 * 1617 = 363
1617 / 363 = 41617 – 4 * 363 = 165
363 / 165 = 2363 – 2 * 165 = 33
5 / 33 = 5165 – 5 * 33 = 0

When temp value is 0, value of denominator is 33 – which is the Greatest Common Divisor of numbers 1980 and 1617.

For list of all c programming interviews / viva question and answers visit: C Programming Interview / Viva Q&A List

For full C programming language free video tutorial list visit:C Programming: Beginner To Advance To Expert