Question 1

In C, what does this recursive function return for the input 123, and why is the result printed twice?  #include<stdio.h> int sumdig(int); int main() {  int a, b;  a = sumdig(123);  b = sumdig(123);  printf("%d, %d ", a, b);  return 0; } int sumdig(…

Accepted Answer

Introduction / Context: The function sumdig recursively computes the sum of the decimal digits of its input. The program calls the function twice with the same constant, then prints both results, testing understanding of recursion and base cases. Given Data / Assumptions: Input n = 123. Base case: if n == 0, return 0. Recursive case: s = (n % 10) + sumdig(n / 10). Concept / Approach: Digit sum decomposition uses integer division and modulo to peel off the least significant digit each call. The recursion terminates when n becomes 0, at which point unwinding adds each digit. Step-by-Step Solution: Call sumdig(123): d = 3, recurse with 12.sumdig(12): d = 2, recurse with 1.sumdig(1): d = 1, recurse with 0.sumdig(0) returns 0 (base case).Unwind: s(1) = 1 + 0 = 1; s(12) = 2 + 1 = 3; s(123) = 3 + 3 = 6.Both a and b receive 6; print "6, 6". Verification / Alternative check: Non-recursive check: 1 + 2 + 3 = 6, confirming the computed result. Why Other Options Are Wrong: "4, 4" and "3, 3" are partial sums; "12, 12" incorrectly sums digits by concatenation or multiplication. "0, 0" contradicts the nonzero input. Common Pitfalls: Forgetting to return 0 at the base case or misplacing the return outside the if/else can cause undefined values. Here the structure is correct and yields 6 consistently. Final Answer: 6, 6

Question 2

In C, what will this program print? Note the comma operator in the function and the space in printf.  #include<stdio.h>  int addmult(int ii, int jj) {  int kk, ll;  kk = ii + jj;  ll = ii * jj;  return (kk, ll); }  int main() {  int i=3, j=4, k, l; …

Accepted Answer

Introduction / Context: This is the same comma-operator behavior as an earlier problem but with a different printf format (space-separated). The function returns the product because the comma operator yields the right-hand operand’s value. Given Data / Assumptions: i = 3, j = 4 → sum 7, product 12. return (kk, ll) → returns 12. printf prints two integers separated by a space. Concept / Approach: The comma operator evaluates left expression, discards it, then evaluates right expression and returns that value. So addmult returns 12. Both assignments to k and l receive 12. Step-by-Step Solution: kk = 3 + 4 = 7, ll = 3 * 4 = 12.return (kk, ll) → returns 12.k = 12, l = 12.printf prints: "12 12". Verification / Alternative check: Replace return (kk, ll) with return ll; compile and run; the output remains "12 12". Why Other Options Are Wrong: There is no compile error; the comma operator is legal. The program clearly outputs, so “No error, No output” is false. “None of above” contradicts the trace. Common Pitfalls: Assuming both values are printed (7 and 12); only the returned value is assigned each time. Final Answer: 12 12

Question 3

In C pointer arithmetic on arrays: what is printed when the function advances a char* pointer over an initialized array?  #include<stdio.h>  int main() {  void fun(char*);  char a[100];  a[0] = 'A'; a[1] = 'B';  a[2] = 'C'; a[3] = 'D';  fun(&a[0]); …

Accepted Answer

Introduction / Context: This problem checks pointer arithmetic with character arrays. Incrementing a char moves to the next character. The code displays two successive characters after a starting position passed by the caller. Given Data / Assumptions: Array a[] has at least four initialized characters: A, B, C, D. fun receives &a[0], the address of the first element. Pointer increments occur twice before each print. Concept / Approach: For char, a++ advances to the next element (next character). The first increment moves from A to B; the second increment moves from B to C. Printing *a after each step reveals those elements. Step-by-Step Solution: Start: a points to a[0] = 'A'.a++ → points to a[1] = 'B'; print 'B'.a++ → points to a[2] = 'C'; print 'C'.Concatenated output: "BC". Verification / Alternative check: Replace prints with indices to confirm the sequence of positions: 1 then 2, corresponding to B then C. Why Other Options Are Wrong: "AB" would require printing before increment; "CD" would require starting at C; "No output" is false because printf is executed. Common Pitfalls: Forgetting that the first print happens after one increment, not at the initial element. Final Answer: BC

Question 4

In C, function pointers and predicates: what does this program print when comparing equal integers?  #include<stdio.h> int fun(int, int); typedef int (*pf) (int, int); int proc(pf, int, int);  int main() {  printf("%d ", proc(fun, 6, 6));  return 0;…

Accepted Answer

Introduction / Context: This program demonstrates using a function pointer (pf) to pass a predicate function into another function. The predicate returns 1 when two integers are equal and 0 otherwise. Understanding function pointer invocation is the key here. Given Data / Assumptions: fun(a, b) returns (a == b), which yields 1 for equal inputs, 0 otherwise. proc takes a function pointer and two ints, and calls the function pointer with those ints. Inputs are (6, 6). Concept / Approach: The function pointer call syntax (*p)(a, b) invokes the function denoted by p with the given arguments. Because 6 equals 6, the predicate evaluates to true, represented as integer 1 in C. Step-by-Step Solution: Assign p = fun via argument passing to proc.Evaluate (*p)(6, 6) → fun(6, 6) → 1.Return value 1 propagates to main and is printed with %d. Verification / Alternative check: Calling fun directly with 6 and 6 yields 1. Changing one argument (e.g., 6 and 5) would print 0, validating the predicate behavior. Why Other Options Are Wrong: 6, -1 are unrelated to equality checks; 0 would mean the numbers were unequal; undefined behavior does not occur because function pointers and arguments are valid. Common Pitfalls: Confusing the equality operator == with assignment =, or misusing function pointer syntax by writing p(a,b) without appropriate declaration (although p(a,b) would also work in C). Final Answer: 1

Question 5

In C, trace control flow with a global controlling a while loop and a recursive call to main(). What is printed?  #include<stdio.h> int i; int fun();  int main() {  while(i)  {  fun();  main();  }  printf("Hello ");  return 0; } int fun() {  printf(…

Accepted Answer

Introduction / Context: This problem checks knowledge of default initialization for global variables in C and the effect on loop execution. It also includes a recursive call to main(), but that code path is guarded by the loop condition. Given Data / Assumptions: Global int i is zero-initialized by default. while(i) executes only if i is nonzero. printf("Hello") executes after the loop. Concept / Approach: In C, global (static storage duration) variables are initialized to 0 if not explicitly initialized. Therefore, i == 0 at program start. The while loop condition is false immediately, so the loop body (including fun() and the recursive call to main()) does not execute. Step-by-Step Solution: Initialize i = 0 (by default).Evaluate while(i) → while(0) → condition false → skip body.Execute printf("Hello").Program terminates normally. Verification / Alternative check: If you explicitly set i = 1 before the loop, the loop would run and call main() recursively, risking non-termination. Since i is 0, none of that occurs. Why Other Options Are Wrong: “Hi Hello” would require entering the loop to print “Hi”. “No output” is false because “Hello” prints. “Infinite loop” would require i to be nonzero. There is no compile-time error for calling main recursively (though it is poor style). Common Pitfalls: Assuming uninitialized globals are garbage; they are zeroed. Confusing this with local automatic variables that are indeterminate if not initialized. Final Answer: Hello

Question 6

In C, analyze recursion via calling main() from main() and a toggled local variable. What is printed?  #include<stdio.h>  int main() {  int i=1;  if(!i)  printf("CuriousTab,");  else  {  i=0;  printf("C-Program");  main();  }  return 0; }

Accepted Answer

Introduction / Context: This program highlights recursion and automatic variable reinitialization. Each call to main() creates a new stack frame with a fresh automatic variable i, changing control flow compared to using a static or global variable. Given Data / Assumptions: Local automatic int i is initialized to 1 at the start of every main() invocation. Branch uses if(!i). With i == 1, the else branch executes. Else branch sets i = 0, prints "C-Program", and calls main() recursively. Concept / Approach: Because i is automatic, each recursive call resets i to 1, causing the else branch to run again. There is no base case to stop recursion, so the program repeatedly prints "C-Program" and recurses indefinitely (likely causing stack overflow eventually). Step-by-Step Solution: First call: i = 1 → else branch → print "C-Program" → call main().Second call: i reinitialized to 1 → else branch again → print "C-Program" → call main().This continues without termination. Verification / Alternative check: If i were static (static int i = 1;), the logic could eventually hit the if branch after setting i = 0 once. But as written, automatic reinitialization keeps the else branch active. Why Other Options Are Wrong: The string "CuriousTab," is never printed because the if branch never runs. There is no compile-time error from placing main() inside else; it compiles but is poor design. The program does not terminate after one print. Common Pitfalls: Assuming i maintains its modified value across recursive calls; with automatic storage, each call has its own i. Final Answer: prints "C-Program" infinitely

Question 7

In C, passing main as a function pointer: what is the program output order?  #include<stdio.h> int fun(int(*)());  int main() {  fun(main);  printf("Hi ");  return 0; } int fun(int (*p)()) {  printf("Hello ");  return 0; }

Accepted Answer

Introduction / Context: This program demonstrates passing a function pointer to another function, including passing the address of main itself. The callee prints a message, returns, and then main prints another message. Understanding call order yields the combined output. Given Data / Assumptions: fun receives a function pointer but does not invoke it. fun prints "Hello " (with a trailing space) and returns. main then prints "Hi". Concept / Approach: Although main is passed to fun, the function pointer is not used to call main again. Therefore, there is no recursion or infinite loop. The output is simply the concatenation of prints in the order of execution. Step-by-Step Solution: Call fun(main) → fun prints "Hello ".Return to main → print "Hi".Combined output: "Hello Hi". Verification / Alternative check: If fun had called (*p)(), a recursive call to main would occur, potentially leading to repeated outputs. Here, it does not call p. Why Other Options Are Wrong: "Infinite loop" would require fun to call p (or main to call itself). "Hi" alone ignores the first print. "Error" is incorrect—the code is valid in C. "Hi Hello" reverses the actual order. Common Pitfalls: Assuming that passing main necessarily means recursion. It only happens if the pointer is actually invoked. Final Answer: Hello Hi

Question 8

In C function-call nesting and assignment evaluation, what will this program print?  #include<stdio.h>  int fun(int i) { i++; return i; }  int main() { int fun(int); int i = 3; fun(i = fun(fun(i))); printf("%d ", i); return 0; }

Accepted Answer

Introduction / Context: This C question tests your understanding of expression evaluation with nested function calls, assignment as an expression, and pass-by-value semantics. Although the code looks compact, the exact order of operations determines the final value stored in the variable i. Given Data / Assumptions: The helper function is int fun(int i) { i++; return i; } Initial value: i = 3 Call sequence in main(): fun(i = fun(fun(i))); Platform-independent standard C behavior (no undefined behavior here). Concept / Approach: The function fun returns its input plus one. Since arguments are passed by value, calls to fun never change the caller’s variable unless an assignment explicitly stores a return value. Also, assignment in C is an expression that yields the value assigned. Step-by-Step Solution: Start with i = 3.Evaluate inner call: fun(i) → returns 4 (local increment), but i in main is still 3.Evaluate next call: fun(4) → returns 5.Perform assignment: i = 5 (assignment value is 5).Evaluate outer call: fun(5) → returns 6, result ignored.Print i which remains 5. Verification / Alternative check: If you rewrote the line as i = fun(fun(fun(i))); then i would become 6. The difference is whether the final function call’s result is assigned back to i. Why Other Options Are Wrong: “4” ignores the two nested increments. “Error” and “Garbage value” do not apply since the code compiles and runs definedly. “Program-dependent” is misleading; the behavior is well-defined in standard C. Common Pitfalls: Mistaking pass-by-value for pass-by-reference; assuming all nested results are assigned; overlooking that the last fun call’s return is discarded. Final Answer: 5

Question 9

In C, evaluate nested assignments and function calls: what does this program print for k?  #include<stdio.h> int func1(int);  int main() { int k = 35; k = func1(k = func1(k = func1(k))); printf("k=%d ", k); return 0; } int func1(int k) { k++; return…

Accepted Answer

Introduction / Context: This classic C puzzle checks understanding of nested function calls, right-associative assignments, and the fact that assignment is an expression whose value is the assigned value. The helper function increments its argument and returns the incremented value. Given Data / Assumptions: int func1(int k) { k++; return k; } increments and returns its input. Initial k = 35. Compound statement: k = func1( k = func1( k = func1(k) ) ); Standard C semantics; each inner expression must be fully evaluated to supply the argument to the next call. Concept / Approach: Work from the innermost parentheses outward. Each func1 call adds 1 to its argument and returns that value. Each k = ... not only stores into k but also yields that stored value, which then becomes the argument to the next outer call. Step-by-Step Solution: Start k = 35.Innermost: func1(k) = 36; assign k = 36.Middle: need k = func1(k): with k = 36, func1(36) = 37; assign k = 37; the middle call is func1(37) = 38; then the middle assignment sets k = 38.Outer: evaluate func1(38) = 39; final outer assignment sets k = 39.Prints “k=39”. Verification / Alternative check: Replace nested form with sequential statements to verify: k=func1(k); k=func1(k); k=func1(k); would give 38; however the given expression performs an extra func1 due to the outer call applied to the already-assigned middle result, hence 39. Why Other Options Are Wrong: “k=38” overlooks that the outermost func1 runs after the middle assignment has already set k to 38. “k=35/36/37” ignore one or more increments. Common Pitfalls: Forgetting that an assignment returns the assigned value; miscounting the number of func1 calls; assuming chained comparisons or left-to-right argument evaluation semantics that do not apply to nested expressions. Final Answer: k=39

Question 10

On a 16-bit Turbo C (DOS) platform using compiler registers, what will this program print?  #include<stdio.h>  int main() { int fun(); int i; i = fun(); printf("%d ", i); return 0; } int fun() { _AX = 1990; // set return register (Turbo C extension)…

Accepted Answer

Introduction / Context: This question targets legacy 16-bit DOS Turbo C behavior where compiler-provided register variables (such as _AX) can be used to specify a function’s return value directly. It assesses platform-specific calling conventions and how return values are passed. Given Data / Assumptions: Compiler: Turbo C in 16-bit DOS. Function prototype: int fun(); In the definition, _AX = 1990; is used without an explicit return statement. On this platform, 16-bit integer return values are delivered in the AX register. Concept / Approach: Many 16-bit compilers map function return values to specific CPU registers. For an int, Turbo C returns via AX. Writing to _AX (a compiler extension naming the register) before the function exits sets the return value exactly as if the function had executed return 1990;. Step-by-Step Solution: Call fun().Inside fun, assign _AX = 1990.Function returns; caller receives AX content as the integer result.Prints 1990. Verification / Alternative check: Replacing _AX = 1990; with return 1990; is portable and yields the same output. The register assignment method is non-portable and specific to Turbo C. Why Other Options Are Wrong: “Garbage value” or “0” would occur only if the convention were different or the code uninitialized the register, which is not the case here. “No output” is incorrect; printf executes. Common Pitfalls: Attempting to use _AX on modern compilers where it is undefined; assuming this trick is portable across architectures or compilers. Final Answer: 1990

Question 11

In C, passing by address and modifying in-place: what does this program print?  #include<stdio.h> void fun(int*, int*); int main() { int i = 5, j = 2; fun(&i, &j); printf("%d, %d", i, j); return 0; } void fun(int *i, int *j) { *i = *i * *i; *j = *j …

Accepted Answer

Introduction / Context: This tests basic C pointer usage with pass-by-address. When you pass addresses and dereference inside the callee, you can modify the caller’s variables directly. Given Data / Assumptions: i = 5, j = 2 in main. Call: fun(&i, &j); In fun, both pointed-to values are squared. Concept / Approach: Since the function parameters are pointers, *i and *j refer to the original variables. Reassigning them updates the caller’s variables. Step-by-Step Solution: Before call: i = 5, j = 2.Inside fun: *i = *i * *i → 25 and *j = *j * *j → 4.After fun returns, i is 25 and j is 4.Printed output: “25, 4”. Verification / Alternative check: Replacing pointer parameters with return values would require returning two values (e.g., via a struct). Pointers allow both updates in one call. Why Other Options Are Wrong: “5, 2” reflects no change. “10, 4” incorrectly squares only one operand. “2, 5” swaps and changes meaning. “25, 2” squares only i. Common Pitfalls: Forgetting to pass addresses; confusing *i * *i with dereferencing precedence (it is simply the product of the dereferenced value with itself). Final Answer: 25, 4

Question 12

Post-increment in a return and pre-decrement in printf: what is printed?  #include<stdio.h>  int main() { int fun(int); int i = fun(10); printf("%d ", --i); return 0; } int fun(int i) { return (i++); }

Accepted Answer

Introduction / Context: This question checks your understanding of post-increment in a return expression and a subsequent pre-decrement before printing. The behavior is completely defined in C. Given Data / Assumptions: fun(10) returns 10 because post-increment returns the operand’s old value. Variable i receives 10. printf("%d", --i); pre-decrements then prints. Concept / Approach: The operator i++ yields the original value and then increments the local copy. Since function parameters are by value, the caller receives 10. The pre-decrement operator --i decrements first, then yields the new value. Step-by-Step Solution: Call fun(10): returns 10 (post-increment proceeds on a temporary inside fun).Assign i = 10.Compute --i: now i = 9.Print 9. Verification / Alternative check: If you changed the body to return (++i);, then i in main would be 11, and --i would print 10. Why Other Options Are Wrong: “10/11/8” do not match the exact operator sequence. Behavior is not undefined here. Common Pitfalls: Confusing pre- and post-increment semantics; assuming pass-by-reference incorrectly modifies the caller’s variable in the callee. Final Answer: 9

Question 13

Recursion with post-decremented actual argument: what does this program do?  #include<stdio.h> int reverse(int);  int main() { int no = 5; reverse(no); return 0; } int reverse(int no) { if (no == 0) return 0; else printf("%d,", no); reverse(no--); }

Accepted Answer

Introduction / Context: This problem focuses on the difference between pre- and post-decrement when used in function-call arguments, and how this interacts with recursion. Using no-- in the call can lead to unexpected non-termination. Given Data / Assumptions: The function prints no whenever it is nonzero. Recursive call uses reverse(no--); Initial call is reverse(5). Concept / Approach: The post-decrement operator yields the current value first and then decrements the variable after the value has been used to form the function argument. Because function arguments are evaluated before the call, the recursive invocation receives the old value, so the parameter does not decrease across recursive levels, causing unbounded recursion. Step-by-Step Solution: First call: prints “5,” then calls reverse(5) again due to post-decrement semantics.Within that call, the same pattern repeats indefinitely.The local no gets decremented after the argument is evaluated, but that decrement affects only the caller’s local copy, not the callee’s argument in the next frame.As a result, the base case no == 0 is never reached. Verification / Alternative check: Change the recursive call to reverse(--no); or reverse(no - 1); to ensure the argument decreases, producing the expected countdown and termination. Why Other Options Are Wrong: A/B/C assume termination with a decreasing sequence to zero, which does not occur here. Common Pitfalls: Believing that no-- lowers the value passed into the next call (it does not); forgetting that post-decrement applies after the value is used. Final Answer: Infinite loop (infinite recursion/stack overflow)

Question 14

Type conversions with nested calls and assignment to a float: what prints?  #include<stdio.h> int fun(int);  int main() { float k = 3; fun(k = fun(fun(k))); printf("%f ", k); return 0; } int fun(int i) { i++; return i; }

Accepted Answer

Introduction / Context: This question examines integer-to-float conversions, nested calls, and assignment expression values. The helper function increments an integer and returns the result. The key point is which value actually gets stored into the float variable k. Given Data / Assumptions: fun(int) returns its argument + 1. k is a float initially 3, but all fun calls take and return int. Statement: fun(k = fun(fun(k))); followed by printf("%f", k); Concept / Approach: Work from the inside out. Conversions occur at call boundaries. Assignment is an expression whose value is the value assigned. The final fun(...) call’s result is not assigned to k unless explicitly stored. Step-by-Step Solution: Inner: fun(k) → argument 3 converted to int 3 → returns 4.Next: fun(4) → returns 5.Assignment: k = 5 (k becomes 5.0; the expression value is 5).Outer call: fun(5) → returns 6, but the result is ignored.Printed value is the stored k = 5.000000. Verification / Alternative check: If the code had been k = fun(fun(fun(k))); then k would be 6. The difference is whether the outermost return value is assigned back to k. Why Other Options Are Wrong: “3.000000/4.000000” ignore the nested increments and the assignment. “Garbage value” does not apply; behavior is defined. “6.000000” would require assigning the outer call’s result to k. Common Pitfalls: Confusing what gets assigned vs. what gets computed; overlooking implicit conversions at call sites. Final Answer: 5.000000

Question 15

Recursion with pre-decrement on both sides of a print: what is the output sequence?  #include<stdio.h> void fun(int); typedef int (*pf)(int, int); int proc(pf, int, int); // (not used)  int main() { int a = 3; fun(a); return 0; } void fun(int n) { i…

Accepted Answer

Introduction / Context: This recursion puzzle shows how pre-decrement (--n) changes the current frame’s local value before both the left and right recursive calls and between them, impacting the sequence of printed numbers. Given Data / Assumptions: Initial call: fun(3). Inside fun: first call fun(--n), then print n, then call fun(--n) again. Pre-decrement updates n before each use. Concept / Approach: Track the changing value of n carefully at each level. The first --n moves from 3 to 2 (then recurses). After returning, printing uses the decremented value from that frame. The second --n reduces once more before the right recursion. Step-by-Step Solution: Level n=3: first --n → 2; call fun(2).Level n=2: first --n → 1; call fun(1).Level n=1: first --n → 0; call fun(0) (returns immediately).Print at level n=1: prints 0, then second --n → -1, right call returns immediately.Back to level n=2: print 1, then second --n → 0, right call returns.Back to level n=3: print 2, then second --n → 1; call fun(1), which prints 0 similarly.Concatenate outputs: 0, 1, 2, 0, Verification / Alternative check: Manually instrumenting with trace messages or drawing a recursion tree confirms the exact print order. Why Other Options Are Wrong: Other sequences misplace the mid-print value or mis-handle the second pre-decrement. Common Pitfalls: Confusing pre-decrement with post-decrement; forgetting that n is mutated between the two recursive calls and before the print. Final Answer: 0, 1, 2, 0,

Question 16

Diagnose the conditional expression and returns: what does this program do?  #include<stdio.h> int check (int, int);  int main() { int c; c = check(10, 20); printf("c=%d ", c); return 0; } int check(int i, int j) { int *p, *q; p = &i; q = &j; i >= 4…

Accepted Answer

Introduction / Context: This problem centers on correct use of the conditional (ternary) operator and the return statement in C. It highlights a syntactic misuse that leads to a compilation error. Given Data / Assumptions: Two local integers i and j with pointers p and q referencing them. The function attempts: i >= 45 ? return(*p) : return(*q); Standard C syntax rules apply. Concept / Approach: The ternary operator has the form condition ? expr1 : expr2. Both expr1 and expr2 must be expressions, not statements. return is a statement and cannot appear directly as an operand of the ternary operator. Step-by-Step Solution: The compiler parses the conditional operator.It encounters return(*p) where an expression is required.This violates syntax rules, causing a compile-time error.The correct code would be either:1) return (i >= 45 ? *p : *q);2) Use an if/else with separate return statements. Verification / Alternative check: Refactor as shown and recompile; the function will then return 20 for inputs (10, 20) because i >= 45 is false. Why Other Options Are Wrong: Options A/B/C suggest a valid return value, but the program never compiles successfully as written. “Undefined behavior” implies a runtime issue, but the code fails earlier at compilation. Common Pitfalls: Forgetting that the ternary operator expects expressions, not statements; attempting to abbreviate if/else syntax too aggressively. Final Answer: Compile error

Question 17

Simple conditional return in C: given i=45, what does this program print?  #include<stdio.h> int check(int); int main() { int i = 45, c; c = check(i); printf("%d ", c); return 0; } int check(int ch) { if (ch >= 45) return 100; else return 10; }

Accepted Answer

Introduction / Context: This checks the basics of conditional branching and return values in C. The function returns one of two constants depending on whether the input meets a threshold. Given Data / Assumptions: Main sets i = 45 and calls check(i). check returns 100 if ch >= 45, otherwise 10. Printed value is whatever check returns. Concept / Approach: Direct evaluation of a relational condition determines which return executes. Since 45 meets the greater-than-or-equal condition, the function takes the first branch. Step-by-Step Solution: Given ch = 45.Evaluate condition ch >= 45 → true.Execute return 100;In main, c receives 100, which is printed. Verification / Alternative check: Testing with ch = 44 yields 10; with ch = 46 yields 100, confirming the threshold behavior. Why Other Options Are Wrong: 10/1/0 do not match the executed branch. No undefined behavior is present. Common Pitfalls: Off-by-one misunderstandings around inclusive comparisons (using >= vs >). Final Answer: 100

Question 18

In C programming, what will be the actual output of this program (consider control flow and the call to exit): #include #include int main() { int i = 0; i++; if (i <= 5) { printf("CuriousTab"); exit(1); main(); } return…

Accepted Answer

Introduction / Context: This C program checks your understanding of control flow, short-circuit termination using exit, and what happens to code that appears after exit. Although the code includes a recursive call to main, the presence of exit(1) changes the practical behavior and prevents recursion from executing. Given Data / Assumptions: Variable i is local to main and initialized to 0 on each call. i is incremented once per entry into main. exit(1) immediately terminates the process and does not return. printf writes "CuriousTab" without a trailing newline. Assume a conforming hosted C environment where exit behaves per the standard. Concept / Approach: Key ideas are: local automatic storage duration (i resets to 0 for each fresh call to main), condition evaluation (i becomes 1, so i <= 5 is true), and the semantics of exit which ends the program immediately. Any statements after exit, including the recursive main(), are unreachable at runtime. Step-by-Step Solution: Start main: i = 0.Increment: i++ makes i = 1.Condition i <= 5 is true → enter if block.printf outputs the string: CuriousTab.exit(1) terminates the program instantly; the subsequent main() call never executes. Verification / Alternative check: Compile and run: you will see one occurrence of the word CuriousTab (no newline). Adding a fflush(stdout) is unnecessary here because exit performs normal program termination and flushes stdout for line-buffered/fully buffered streams connected to terminal or files. Why Other Options Are Wrong: Prints "CuriousTab" 5 times: would require loop/recursion to continue; exit prevents this.Function main() does not call itself: the call is present syntactically, but it is never reached.Infinite loop: program terminates via exit.Compilation error due to recursion: calling main is permitted by the standard, though usually discouraged. Common Pitfalls: Assuming exit returns; believing local i persists across calls; expecting recursion to proceed before process termination. Final Answer: Prints "CuriousTab"

Question 19

C language semantics: “In C, all functions except main() can be called recursively.” Decide whether this statement is correct or incorrect.

Accepted Answer

Introduction / Context: This item probes knowledge of recursion legality in standard C. Many learners believe main is special and cannot be called recursively. In reality, the C standard does not prohibit calling main as an ordinary function from within the program, although it is rarely useful and sometimes frowned upon stylistically. Given Data / Assumptions: We are discussing the ISO C language definition. Recursion means a function directly or indirectly calling itself. We are not discussing program startup entry semantics performed by the runtime before main is first invoked. Concept / Approach: Any function in C may call any other function whose prototype is visible, including itself (recursion). The standard describes program execution beginning at main, but it does not ban calling main again as a regular function. Practical concerns (reentrancy, stack usage, and readability) make recursive calls to main unusual, yet they are permitted. Step-by-Step Solution: Identify claim: “all functions except main can be recursive.”Check the standard: no rule forbids calling main.Conclude the statement is incorrect because main can be called recursively as well. Verification / Alternative check: Write a trivial example where main calls main a limited number of times using a static counter to avoid infinite recursion; compilers accept this, and the program runs as expected. Why Other Options Are Wrong: Correct: contradicts the language rules.Depends on compiler extensions: not required; standard C already allows it.Not defined / Applies only to C++: both misstate the language behavior. Common Pitfalls: Confusing OS process entry with ordinary function calls; assuming “specialness” of main extends to semantics inside the program. Final Answer: Incorrect

Question 20

C return semantics: “Functions cannot return more than one value at a time.” Decide whether this statement is correct or incorrect.

Accepted Answer

Introduction / Context: The question examines how C function returns work. In C, a function executes and produces exactly one returned object via the return mechanism. Understanding this clarifies design patterns involving output parameters, structures, and tuples. Given Data / Assumptions: C return statement transfers control back to the caller and optionally provides one value. We distinguish between “returning one object” versus “communicating multiple results by other means.” We consider standard C without language extensions like multiple return values found in some other languages. Concept / Approach: A C function can return exactly one value in the language sense. However, that one value can be a compound object (e.g., a struct) containing multiple fields, or the function can write to memory via pointer parameters to communicate additional outputs. These do not change the rule that the return statement delivers a single value. Step-by-Step Solution: Recognize claim: multiple direct returns are not supported.Check mechanism: return expression yields one value (or no value for void).Alternative patterns: use struct return or pointers to “return” additional data.Conclusion: the statement is correct about the return mechanism itself. Verification / Alternative check: Try to write “return a, b;” to return two separate values — this does not return two values; the comma operator still yields a single result. Returning a struct like “struct pair { int x; int y; }; return (struct pair){x, y};” still returns one object. Why Other Options Are Wrong: Incorrect: would only be true in languages with multiple return values; C is not one.Other choices mention void, optimization, or pointers, which do not alter the single-return rule. Common Pitfalls: Confusing “one returned object” with “one piece of information.” A struct return can carry several fields but is still one value. Final Answer: Correct

Functions Questions