Function Practice Questions

A macro definition acts as a template, where symbols provided in the header serve as placeholders for the logic within the body. In the syntax macro Add x, y, the identifiers $x$ and $y$ are defined to represent the inputs required by the macro. These symbolic placeholders used within the definition header are standardly referred to as formal parameters. In contrast, actual parameters are the specific values supplied only when the macro is subsequently invoked. Therefore, since $x$ and $y$ appear in the macro definition header, they are classified as formal parameters.

Given the string $s = "acbc"$:

1. $head(s) = 'a'$
2. $tail(s) = "cbc"$, therefore $tail(tail(s)) = "bc"$
3. $head(tail(tail(s))) = head("bc") = 'b'$
4. $concat(head(s), head(tail(tail(s)))) = concat('a', 'b') = "ab"$

The program defines a global variable $X$ of type integer, which is initialized to $2$.
The procedure FIND(X:real) accepts a formal parameter $X$, which is passed by value by default in Pascal.
Inside FIND, the assignment $X := \sqrt{X}$ operates only on the local parameter $X$, creating a local scope that does not affect the global variable.
Since the global variable $X$ remains unchanged after the procedure call, it retains its initial value of $2$.
Consequently, writeln(X) prints the global value of $2$.

Call-by-reference computes the address of the actual parameter once upon the function call, using that fixed memory location throughout the function's execution. Conversely, call-by-name acts as a macro, re-evaluating the expression every time the parameter is accessed. When passing an array element like $A[i]$, call-by-reference binds to the address of the specific index at the time of the call. If the index variable $i$ is modified within the function, call-by-name re-evaluates $A[i]$ using the updated value of $i$, accessing a different memory location. In contrast, call-by-reference remains bound to the original memory address determined at invocation, thus leading to different results.

The variable $m$ is declared in the global scope of the main program PARAM. In block-structured languages like Pascal, the lexical scope of a globally declared variable extends throughout the entire program, including all nested procedures. While a local variable $m$ declared inside procedure $P$ may shadow (mask) the global $m$ within that procedure, the lexical scope of the global $m$ still encompasses $P$ and $Q$. Therefore, the scope of the $m$ declared in PARAM includes the main program PARAM itself, as well as procedures $P$ and $Q$.

In Pascal, formal parameters are passed by value unless the var keyword is explicitly used to denote pass-by-reference. In the procedure $P$, the parameters $x$ and $y$ are passed by value, meaning the call $P(m, m)$ initializes $x$ and $y$ with the current value of the global $m$, which is $0$. Inside $P$, the assignment $x := y + 1$ modifies only the local parameter $x$, and the locally declared variable $m$ is distinct from the global $m$. Thus, the global variable $m$ is never modified during the execution of $P$. Consequently, after the procedure call, the global $m$ retains its initial value of $0$.

In the procedure $P(m, m)$, both parameters $x$ and $y$ are passed by reference, effectively creating an alias for the variable $m$. When $x := y + 1$ is executed, the global $m$ is updated to $0 + 1 = 1$, so write(m) outputs $1$.
In the call $Q(n*1, n)$, the value $0$ is passed to the value parameter $x$, and the variable $n$ is passed by reference to the variable parameter $y$.
Inside $Q$, the assignment $x := y + 1$ modifies the local copy of $x$, but does not update $y$ (and thus does not modify $n$).
Consequently, $n$ remains $0$, and write(n) outputs $0$.
Since the provided options A through D fail to correctly explain the mechanism behind the result, the correct choice is E.

[CORRECT_OPTION: E]

The described sequence implements Call-by-Value-Result (also known as copy-restore). In this mechanism, the actual parameter $A[i]$ is evaluated and copied into a local variable $z$ before the procedure $P$ starts (value phase). The procedure then executes using only $z$. Finally, the updated value of $z$ is copied back to the memory location of $A[i]$ upon termination (result phase). This implementation is correct; evaluating the address of $A[i]$ at the start ensures that even if $i$ is modified within $P$, the final result is correctly stored in the original location determined before execution.

The function loop while i*i < M continues incrementing $i$ until the condition $i^2 \geq M$ is met.
The loop terminates at the smallest integer $i$ that satisfies $i^2 \geq M$.
By definition, the ceiling function $\lceil \sqrt{M} \rceil$ returns the smallest integer $k$ such that $k \geq \sqrt{M}$, which is algebraically equivalent to $k^2 \geq M$.
For example, if $N=5$, the loop runs for $i=0, 1, 2$ ($2^2=4 < 5$) and terminates when $i=3$ ($3^2=9 \geq 5$), returning $3$, which matches $\lceil \sqrt{5} \rceil = 3$.
Thus, the function correctly calculates $\lceil \sqrt{N} \rceil$.

Call-by-reference evaluates the argument once at the time of the call, passing the fixed memory address to the function. Conversely, call-by-name substitutes the argument's code directly into the procedure body, causing it to be re-evaluated upon every access.

For A (Passing an expression), call-by-name re-evaluates the expression whenever it is used, while call-by-reference uses the value or address calculated once at the start.
For D (Passing an array element), such as $A[i]$, call-by-reference determines the address of the specific index $i$ once. In contrast, call-by-name re-evaluates $A[i]$ during every access; if the index $i$ is modified within the procedure, call-by-name accesses different array elements, leading to different results compared to call-by-reference.

[CORRECT_OPTION: A, D]

In dynamic scoping, the program searches the call stack for the most recent variable binding.

1. Global variables are initialized: $x = 7, y = 8$.
2. Procedure $Q$ is called, declaring local variables $x = 3, y = 4$, which shadow the global ones.
3. $Q$ calls $P(4)$. Inside $P$, the assignment $x := (4+2)/(4-3)$ uses the most recent binding for $x$, which is $Q$'s local $x$. Thus, $Q$'s $x$ is updated to $6$.
4. Write statement (1) executes within $Q$, printing $Q$'s local $x$, which is $6$.
5. After $Q$ returns, the main scope is active, where the global $x$ remains unchanged at $7$.
6. Write statement (2) executes in the main block, printing the global $x$, which is $7$.

1. In static scoping, procedure $P$ is defined at the global level, so its reference to $x$ points to the global variable $x$.
2. Inside procedure $Q$, local variables $x$ and $y$ are declared, which shadow the global $x$ and $y$.
3. Within $Q$, the statement $x:=3$ assigns 3 to the local $x$. Calling $P(4)$ executes $x:=(4+2)/(4-3)=6$, which updates the global $x$ because $P$ is globally defined.
4. The write statement (1) refers to the local $x$ of procedure $Q$, printing 3.
5. After $Q$ returns, the write statement (2) in the main block refers to the global $x$, which now holds the value 6.