Functions And Recursion In C : MCQs & PYQs with Explanation

Option C

The given algorithm calculates the factorial of a number N using a function that calls itself with N−1, a clear example of Recursion.

Option B

The printf statement is executed once for each recursive call before reaching the base case (n==0). Therefore, it executes 5 Times.

Option D

A function in C language is a block of code that performs a specific task. Functions help in dividing a large program into smaller, manageable parts, which makes the program easier to understand, write, and maintain.
Functions are executed only when they are called and help in better memory utilization because the same function code can be reused multiple times instead of writing the same code again.

Option B

In C, when an array is passed to a function, the base address of the array is passed, not a copy of all its elements. 
The array name itself represents the address of the first element, so any modification made to the array elements inside the function affects the original array. Because the function receives the address and works directly on the original data.

• Array parameter passing in C is considered Call by Address.
• Arrays are never passed element by element, only their base address is passed to functions.

#include<stdio.h>
void changeValue(int crr[])
{
    int i;
    for(i=0;i<3;i++)
        crr[i]=crr[i]+5;
}
void main()
{
    int i;
    int arr[3]={10,20,30};
    changeValue(arr);
    for(i=0;i<3;i++)
        printf("%d ",arr[i]);
}
OUTPUT
15 25 35

Option A

In programming, when a function is called, its local variables and function calls are stored in the Stack memory, not in the Heap.

Option B

The program uses a recursive function f() with a static variable r, which retains its value across all recursive calls. 
When f(5) is called, the condition n>3 is true, so r is assigned the value 5, and the function returns f(3)+2. 
For f(3), the condition n>3 is false and n<=0 is also false, so the function executes the last return statement f(n-1)+r. Since r is static and already set to 5, it remains unchanged in all subsequent calls.
The recursion continues as f(3) = f(2)+5, f(2)=f(1)+5, and f(1)=f(0)+5. When f(0) is reached, the condition n<=0 becomes true and the function returns 1.
The return values are then calculated as follows:

• f(1) = 1+5 = 6
• f(2) = 6+5 = 11
• f(3) = 11+5 = 16
• f(5) = 16+2 = 18

Therefore, the output printed by the program is 18.

Option A

In C/C++, a Function Declaration (Prototype) is used to inform the compiler about the function before its actual use. The essential components required in a function declaration are the return type and the function name.

• Parameters are optional in declaration because, a function can have no parameters.

E.g.:

• void myFun(); // Valid declaration.
• int sum(); // Valid declaration.

Option C

In C language, function declarations or prototypes and definitions must be consistent in terms of parameters. If a function is declared with parameters, then its definition must also match the same parameter list.
Inside main(), the function f1 is declared as void f1(int), which means it expects one integer argument. However, the function is called as f1() without passing any argument, and its actual definition is also without parameters. This creates a mismatch between declaration, definition, and function call, which leads to a Compile-Time Error.
Note:
In C language, a function can be declared multiple times, but all declarations must be consistent (same return type and same parameters).
Multiple declarations do not create any problem as long as they are identical. The compiler simply treats them as repeated information about the same function.
E.g.:
void f1();
void f1();   // Repeated Declaration (Allowed)
int main() 
{
    f1();
}
void f1() 
{
    printf("Hello, Suresh");
}

Option A

A function is a block of code written to perform a specific task. Functions help in organizing a program into smaller parts, which makes the program clear, reusable, and easy to manage.

• Functions divide a large program into smaller modules, which is called modularization.
• Better memory utilization means using the computer’s memory efficiently without wastage. When we use functions, the same block of code is written only once in memory and can be called multiple times.
• Functions allow code reusability, which avoids writing the same code repeatedly.
• Errors can be easily found and fixed when the program is divided into functions. It makes debugging easier.

Option A

This program demonstrates call by value in C. When modify(x,y) is called, the values of x and y are copied into local variables a and b. Inside the function, a becomes 15 and b becomes 27, which are printed. However, changes to a and b do not affect the original variables in main, so x and y remain 5 and 7.