Function Practice Questions

When an expression like $ib + 5$ is passed by reference in FORTRAN, the compiler evaluates the expression, stores the result ($8 + 5 = 13$) in a temporary memory cell, and passes the address of this cell to the subroutine, making S1 correct. Inside swap(ix, iy), $ix$ refers to $ia$ and $iy$ refers to the temporary cell. The subroutine executes $it = ix$ ($3$), $L1: ix = iy$ ($ia = 13$), and $L2: iy = it$ ($tmp = 3$). Since the address of $ib$ itself was not passed, $ib$ remains $8$ in the main program, confirming S4 is correct while S2 and S3 are incorrect as all memory accesses are valid.

The function fun(n, f_p) calculates Fibonacci-like numbers. Let's trace its execution for fun(5, &x):

1. fun(1, &x): Base case. *f_p = 1. Returns 1. (At this point, x becomes 1).
2. fun(2, &x):
   • Calls fun(1, &x). t becomes 1. (x is 1).
   • f = t + *f_p = 1 + 1 = 2.
   • *f_p = t = 1. (x remains 1).
   • Returns 2.
3. fun(3, &x):
   • Calls fun(2, &x). t becomes 2. (x is 1).
   • f = t + *f_p = 2 + 1 = 3.
   • *f_p = t = 2. (x becomes 2).
   • Returns 3.
4. fun(4, &x):
   • Calls fun(3, &x). t becomes 3. (x is 2).
   • f = t + *f_p = 3 + 2 = 5.
   • *f_p = t = 3. (x becomes 3).
   • Returns 5.
5. fun(5, &x):
   • Calls fun(4, &x). t becomes 5. (x is 3).
   • f = t + *f_p = 5 + 3 = 8.
   • *f_p = t = 5. (x becomes 5).
   • Returns 8.

The printf statement prints the value returned by fun(5, &x), which is $8$.

The final answer is $\boxed{B}$

The function $f1(n)$ follows the recurrence $f1(n) = 2f1(n-1) + 3f1(n-2)$ with base cases $f1(0)=0$ and $f1(1)=1$. Computing subsequent terms: $f1(2)=2$, $f1(3)=7$, $f1(4)=20$, $f1(5)=61$, $f1(6)=182$, $f1(7)=547$, and $f1(8)=2(547)+3(182)=1640$. For $f2(n)$, we observe $Y[i-1] = 2X[i-1]$ and $Z[i-2] = 3X[i-2]$, which reduces the recurrence to $X[i] = 2X[i-1] + 3X[i-2]$. Since the recurrence relation and initial values $X[0]=0, X[1]=1$ are identical to $f1(n)$, $f2(8)$ must also equal $1640$. Therefore, both functions return $1640$.

The function $f(n)$ recursively computes the binary representation of a decimal number $n$ by dividing by $2$ and printing the remainders in reverse order. For $f(173)$, the recursive divisions are: $173 \div 2 = 86$ (remainder $1$), $86 \div 2 = 43$ (remainder $0$), $43 \div 2 = 21$ (remainder $1$), $21 \div 2 = 10$ (remainder $1$), $10 \div 2 = 5$ (remainder $0$), $5 \div 2 = 2$ (remainder $1$), $2 \div 2 = 1$ (remainder $0$), and $1 \div 2 = 0$ (remainder $1$). The prints occur after the recursive calls unwind, processing the remainders from the final division back to the first. This results in the binary sequence $10101101$.

In the main function, $c$ is initialized to $4$, $b$ points to $c$ ($b=\&c$), and $a$ points to $b$ ($a=\&b$).
When f(c, b, a) is called, $x$ receives the value $4$, $py$ points to $c$, and $ppz$ points to $b$.
Inside f, **ppz += 1 increments $c$ to $4+1=5$, and $z$ is assigned $5$.
Next, *py += 2 increments $c$ (which is $5$) by $2$, so $c$ becomes $7$, and $y$ is assigned $7$.
The local variable $x$ is incremented by $3$ to $4+3=7$.
Finally, the function returns $x+y+z = 7+7+5 = 19$.

The original function $f(n)$ converts the integer $n$ into its binary representation by recursively dividing by 2 and printing the remainders after the recursive call, effectively outputting bits from most significant to least significant.
In $P1$, the logic is identical: the recursive call f(n/2) happens before printing n%2, ensuring the bits are printed in the same order (MSB to LSB) as the original function.
Conversely, $P2$ performs the printf before the recursive call f(n/2), which prints the remainders in reverse order (LSB to MSB), resulting in the bit-reversed binary representation.
Since $f(173) = 10101101_2$, $P1$ outputs $10101101$, while $P2$ outputs $10110101$.
Therefore, only $P1$ produces the same output as the original code.

The function reverse() uses recursion to process input characters in LIFO (Last-In-First-Out) order, which is ideal for reversing a string. To achieve this, each recursive call must store the input character locally, call itself until the newline character is reached, and then output the characters as the stack unwinds.

1. ?1 must read a character $c$ and verify that it is not the newline character: (c = getchar()) != '\n'.
2. This condition correctly captures the character into variable $c$ and controls the recursion depth.
3. Once the base case is reached, the function begins returning. ?2 must print the character $c$ associated with the current stack frame using putchar(c).
4. The LIFO nature of the recursion ensures that the characters are printed in reverse order as the calls return.
5. Consequently, ?1 is (c = getchar()) != '\n' and ?2 is putchar(c).

The static variable $i$ is initialized to $1$ only once. The function executes recursively as follows:

1. $f(1)$: Since $n = 1 < 5$, $n$ becomes $1 + 1 = 2$ and $i$ becomes $2$, calling $f(2)$.
2. $f(2)$: Since $n = 2 < 5$, $n$ becomes $2 + 2 = 4$ and $i$ becomes $3$, calling $f(4)$.
3. $f(4)$: Since $n = 4 < 5$, $n$ becomes $4 + 3 = 7$ and $i$ becomes $4$, calling $f(7)$.
4. $f(7)$: Since $n = 7 \ge 5$, the function returns $n = 7$.
   The final value returned is $7$.

Initialize $num1 = 5$ and $num2 = 4$. The conditions $num1 < num2$ ($5 < 4$) are false, so the calls to swap1 and swap2 do not execute. The final condition $num1 \ge num2$ ($5 \ge 4$) is true, invoking swap3(&num1, &num2). This function correctly swaps the values of the variables using pointers, updating $num1$ to $4$ and $num2$ to $5$. The printf statement then outputs the values $4, 5$.

The function defines base cases for $K < 3$ as $F(0)=0$, $F(1)=1$, and $F(2)=2$.
For $K=3$, the recurrence $F(K) = F(K-1) \cdot F(K-2) + F(K-3)$ gives:
$F(3) = F(2) \cdot F(1) + F(0) = 2 \cdot 1 + 0 = 2$.
For $K=4$, the recurrence gives:
$F(4) = F(3) \cdot F(2) + F(1) = 2 \cdot 2 + 1 = 5$.

For Call by Value, $x$ and $y$ are local copies of the arguments. Inside procedure $f$, the statement $i = 100$ updates the global $i$. Local variables $x$ and $y$ are modified, but these changes do not affect the original arguments $i$ and $j$ in the main program. The final output is $i = 100, j = 60$.

For Call by Reference, $x$ and $y$ are aliases for $i$ and $j$. Inside procedure $f$, $i = 100$ sets the global $i = 100$. The statement $x = 10$ updates the alias $x$ (which is $i$) to $10$. Finally, $y = y + i$ updates the alias $y$ (which is $j$) to $j + i = 60 + 10 = 70$. The final output is $i = 10, j = 70$.

The function demo(x) operates recursively. It prints the last digit, $x \pmod{10}$, calls demo(x / 10), and then prints the last digit again as the recursion unwinds.

1. demo(1234) prints $4$, then calls demo(123).
2. demo(123) prints $3$, then calls demo(12).
3. demo(12) prints $2$, then calls demo(1).
4. demo(1) prints $1$. The recursion effectively terminates here (as demo(0) would not produce the output in the target options).
5. As the stack unwinds, each function completes its final System.out.print(x % 10): demo(1) prints $1$, demo(12) prints $2$, demo(123) prints $3$, and demo(1234) prints $4$.
6. The combined output sequence is $4, 3, 2, 1, 1, 2, 3, 4$.

In static scoping, variable resolution follows the lexical structure of the program. Since $g$ is defined at the global level, it references the global variable $i$. When $g$ is called, it prints the value of the global $i$, which was set to $10$ in $main$, so $x = 10$.

In dynamic scoping, variable resolution follows the active call stack. When $g$ executes print i, it searches the stack for the most recent binding of $i$. Since $g$ is called by $f$ (which has a local variable $i = 20$), $g$ resolves $i$ to the value defined in $f$, so $y = 20$.

Thus, $x = 10$ and $y = 20$.

The function $f(n)$ is defined as $f(n) = f(n/2)$ if $n$ is even, and $f(n) = f(3n-1)$ if $n$ is odd ($n > 1$).
For $n=5$, the sequence is $5 \to 14 \to 7 \to 20 \to 10 \to 5$, which forms a cycle, meaning $f(5)$ does not terminate. Since any $n$ that reduces to a value in this cycle (e.g., $n = 5 \cdot 2^k$ or $7 \cdot 2^k$) also will not terminate, $f$ does not terminate for infinitely many values (iv is true).
Conversely, many values, such as all powers of $2$ ($n=2^k$), reduce directly to $1$ (e.g., $f(2^k) = f(2^{k-1}) = \dots = f(1) = 1$), meaning $f$ terminates for infinitely many values (ii is true).
Thus, both statements ii and iv are correct.

The static variable r is initialized to $0$ and retains its value across recursive calls.

1. f(5): Since $5 > 3$, r becomes $5$. The function returns f(3) + 2.
2. f(3): Since $3 \not> 3$, the function returns f(2) + r (i.e., f(2) + 5).
3. f(2): Since $2 \not> 3$, the function returns f(1) + r (i.e., f(1) + 5).
4. f(1): Since $1 \not> 3$, the function returns f(0) + r (i.e., f(0) + 5).
5. f(0): Since $0 \le 0$, the function returns $1$.

Now, substitute back the results:
$f(1) = f(0) + 5 = 1 + 5 = 6$
$f(2) = f(1) + 5 = 6 + 5 = 11$
$f(3) = f(2) + 5 = 11 + 5 = 16$
Finally,
$f(5) = f(3) + 2 = 16 + 2 = 18$
The value of f(5) is $18$.

The function uses the recursive Pascal's identity $\binom{m}{n} = \binom{m-1}{n} + \binom{m-1}{n-1}$ to calculate the binomial coefficient. For this recursion to terminate correctly, we must define the base cases where $\binom{m}{n} = 1$. The identity $\binom{m}{n} = 1$ holds when $n = 0$ (choosing 0 items) or when $m = n$ (choosing all items). Therefore, the function must return 1 whenever $n = 0$ or $m = n$. This corresponds to the logical OR condition $(n == 0) || (m == n)$.

The provided code implements an arithmetic swap: if $px \neq py$, it calculates $*px = *px - *py$, then $*py = (*px - *py) + *py = *px_{old}$, and finally $*px = *px - *py = *py_{old}$. However, if $px == py$ (aliasing), the logic sets the value at that address to $0$ instead of swapping, which makes S4 true. Because the function dereferences $px$ and $py$ without checking for NULL or validity, it may trigger a segmentation fault if invalid pointers are passed, making S2 true. S1 is false as the code is syntactically valid; S3 is false due to the aliasing bug; and S5 is false because the arithmetic is performed on dereferenced integers, not the pointer addresses themselves.

In swap, the local pointers x and y are swapped, but the actual values of a and b in printab remain unchanged. Because i, a, and b are static in printab, they retain their values between calls.
First call: a starts at $-3$, b at $-6$. The loop runs for $i=0, 2, 4$:

• $i=0$: $a = -3+1 = -2, b = -6+1 = -5$.
• $i=2$: $a = -2+3 = 1, b = -5+3 = -2$.
• $i=4$: $a = 1+5 = 6, b = -2+5 = 3$. Prints: a = 6, b = 3.
  Second call: a starts at $6$, b at $3$.
• $i=0$: $a = 6+1 = 7, b = 3+1 = 4$.
• $i=2$: $a = 7+3 = 10, b = 4+3 = 7$.
• $i=4$: $a = 10+5 = 15, b = 7+5 = 12$. Prints: a = 15, b = 12.

In a pass-by-reference language, the compiler handles the expression ib+5 by creating a temporary nameless cell initialized to the value $13$ ($8+5$) and passing its address to swap, making S1 correct. During the execution of swap(ia, ib+5), ix refers to ia and iy refers to the temporary cell. The operations execute as: it = ia ($3$), ia = 13 (via ix = iy), and temp_cell = 3 (via iy = it). After the subroutine returns, ia is updated to $13$, while ib remains $8$, which is printed correctly, confirming S4 is true. There are no runtime errors, so S2 and S3 are false.