Jamia Millia Islamia MCA C Programming Language Previous Year Questions (PYQs) – Page 2 of 5
A Place for Latest Exam wise Questions, Videos, Previous Year Papers,
Study Stuff for MCA Examinations
Study Stuff for MCA Examinations
What is the output of the following C code segment?
int i;
for(i = 0; i <= 2; i++)
{
switch(i)
{
case 1: printf("%2d", i);
case 2: printf("%2d", i); continue;
default: printf("%2d", i);
}
}
1
2
3
4
Solution
Solution:
Let’s analyze iteration by iteration —
**Iteration 1:** `i = 0`
→ `switch(0)` → goes to `default:` → prints `0`.
**Iteration 2:** `i = 1`
→ executes `case 1:` → prints `1`
→ no `break`, so it falls through to `case 2:` → prints `1`
→ encounters `continue;` → skips remaining statements in the `for` loop body and proceeds to next iteration.
**Iteration 3:** `i = 2`
→ executes `case 2:` → prints `2`
→ `continue;` moves control to the next iteration, but loop ends because `i <= 2` condition fails.
Final output:
`0 1 1 2`
What is the output of the following C program?
int main()
{
char ch = 'A';
int x = 97;
int y = sizeof(++x);
printf("\nx is %d", x);
while (ch <= 'F')
{
switch (ch)
{
case 'A':
case 'B':
case 'C':
case 'D': ch++; break;
case 'E':
case 'F': ch++;
}
putchar(ch);
}
return 0;
}
1
2
3
4
Solution
Solution:
1️⃣ `int y = sizeof(++x);`
→ `sizeof` is a compile-time operator, so `++x` is **not evaluated**.
Hence, `x` remains unchanged (`x = 97`).
2️⃣ `printf("\nx is %d", x);`
→ prints: `x is 97`
3️⃣ Loop execution:
| ch | switch(ch) executes | putchar(ch) prints | next value of ch |
|------|----------------------|--------------------|------------------|
| 'A' | falls to case 'D' → ch++ → break | prints `'B'` | 'B' |
| 'B' | falls to case 'D' → ch++ → break | prints `'C'` | 'C' |
| 'C' | falls to case 'D' → ch++ → break | prints `'D'` | 'D' |
| 'D' | case 'D' → ch++ → break | prints `'E'` | 'E' |
| 'E' | case 'E' → fall through to case 'F' → ch++ | prints `'F'` | 'F' |
| 'F' | case 'F' → ch++ | prints `'G'` | 'G' (loop ends) |
Output sequence = `x is 97 BCDEFG`
What is the output of following C program?
void e(int x)
{
if (x > 0)
{
e(- -x);
printf("%2d", x);
e(- -x);
}
}
int main()
{
e(3);
return 0;
}
1
2
3
4
Solution
Solution:
In C, the tokens `- -x` are parsed as two unary minuses with a space, i.e. $-(-x)=x$.
So both recursive calls are `e(x)`, not `e(--x)`.
For `x=3`, the function calls itself **with the same positive value** forever:
`e(3) → e(3) → e(3) → ...` and never reaches a base case.
This causes infinite recursion (stack overflow) at run time.
Minimum & Maximum range of values for ‘float’ data type in C is:
1
2
3
4
Solution
In standard C (IEEE-754 single precision),
the approximate range of a `float` is from $1.17 \times 10^{-37}$ to $3.4 \times 10^{38}$.
Which out of these is NOT valid for C language?
1
2
3
4
Solution
Solution:
When a local variable has the same name as a global variable,
the **local variable overrides** (takes precedence over) the global one inside its block.
Thus (C) is **invalid** for C.
The output of following C language statement is:
printf("\nhello" + 3);
1
2
3
4
Solution
Solution:
String: "\nhello"
Character positions:
0:'\n' 1:'h' 2:'e' 3:'l' 4:'l' 5:'o'
→ "\nhello" + 3 points to index 3, i.e., `"llo"`
Hence it prints “llo”.
Give output of following C code:
int count(unsigned x)
{
int b;
for (b = 0; x != 0; x >>= 1)
if (x & 1)
b++;
return b;
}
int main()
{
unsigned int a = 3;
printf("%d", count(a));
return 0;
}
1
2
3
4
Solution
```ruby
Solution:
The function `count()` counts number of 1-bits in the binary representation of `x`.
For `a = 3`
Binary of 3 = `11`
→ Number of 1 bits = 2
Hence output = 2.
What is the data type of the following expression:
expr₁ ? expr₂ : expr₃
if expr₁ is of type float & expr₂ is of type int.
1
2
3
4
Solution
Solution:
In the **ternary operator** `(expr₁ ? expr₂ : expr₃)`,
the **data type of result** is the **common type** of `expr₂` and `expr₃`.
Here,
- `expr₁` → condition (float type, irrelevant for result type)
- `expr₂` → int
- `expr₃` → (not specified but implied same as expr₂ type logic)
When int and float are combined → **result type = float** (implicit type conversion).
Which operator out of these has got the highest precedence?
1
2
3
4
Solution
Solution:
Operator precedence (from high to low in C):
`[]` > `<` > `?:` > `,`
Therefore, the highest precedence among these is **array subscript `[ ]`**.
Which operator out of these has left to right associativity?
1
2
3
4
Solution
Operator associativity in C:
- Most unary operators (!, ++, --, sizeof, etc.) → **Right to Left**
- Conditional (`?:`) → **Right to Left**
- Comma operator (`,`) → **Left to Right**
Hence, only the **comma operator** has **left-to-right** associativity.
Jamia Millia Islamia MCA
Online Test Series, Information About Examination,
Syllabus, Notification
and More.
View More
Jamia Millia Islamia MCA
Online Test Series, Information About Examination,
Syllabus, Notification
and More.
View More
Ask Your Question or Put Your Review.
