CS Free MCQ Bank

[ 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.

[ Option B ]

The given function is a form of the Ackermann Function, which is a well-known recursive function with multiple recursive calls.
The function is defined as:

• If m == 0 then return n+1
• If m !=0 and n == 0 then return ak(m-1,1)
• Otherwise return ak(m-1, ak(m, n-1))

The final value obtained after all recursive substitutions is 3.

[ Option C ]

When myFunction(5) is called, the variable sum is initially set to 0. The for loop runs from i=1 to i=5, and in each iteration, the value of i is added to sum. So, the calculation becomes, 1+2+3+4+5 = 15. After the loop completes, the function prints the value of sum, which is 15.

[ Option B ]

In this program, there are two variables with the same name num. One is a global variable (num = 35), and the other is a local variable inside main() (num = 45).
When a local and global variable have the same name, the local variable gets priority inside the function. It means the global variable is hidden inside the function.
So inside main(), when printf("%d %d", num, num); runs, it uses the local variable both times. The local variable has the value 45, so both %d will print 45.

[ Option B ]

In the main function, i=0 and j= . When func(&i,&j) is called, the pointer p receives the address of i, and q receives the address of j.
Inside the function, the statement p=q; makes the local pointer p point to the same location as q, i.e., the address of j. This change affects only the local copy of p, not the original pointer in main.
Next, the statement *p=2; modifies the value at the address where p is pointing. Since p now points to j, the value of j becomes 2. The value of i remains unchanged.
Therefore, the value of i remains 0 and the value of j becomes 2, so the output printed is 0, 2.

[ Option B ]

In this program, a variable named num is first declared in the main() function with the value 20. Inside the next block, another variable with the same name num is declared and given the value 10. This inner variable exists only within its block, and once the block ends, this inner num is no longer accessible. The outer num with value 20 remains unchanged. 
When the printf("%d", num); statement executes, it refers to the outer variable because the inner one has already gone out of scope. Therefore, the program prints 20.

[ Option C ]

The function f() uses a static variable i, which means its value is preserved across recursive calls. Initially, i = 1. 
The function is first called as f(1). Since condition n>=5 is false, the value of n is updated to n+i, so n becomes 2, and then i is incremented to 2. The function calls itself again with f(2).
In the next call, n becomes 2+2 = 4, and i is incremented to 3, followed by a recursive call f(4).
Again, since condition n>=5 is false, n becomes 4+3 = 7, and i becomes 4, and the function calls f(7).
Now the condition n>=5 is true, so the function returns 7. This value is returned through all previous recursive calls without any further modification. Therefore, the final value printed is 7.