Arithmetic Operation Practice Questions

Given ASCII values 'P' $= 80$ ($01010000_2$) and 'x' $= 120$ ($01111000_2$):

• $c = (80 \& 120) + 42 = 80 + 42 = 122$, which corresponds to 'z'.
• $d = (80 | 120) - 45 = 120 - 45 = 75$, which corresponds to 'K'.
• $e = (80 \oplus 120) + 43 = 40 + 43 = 83$, which corresponds to 'S'.
  The printf function outputs the characters corresponding to the resulting integer values $122, 75, 83$, which are 'z', 'K', and 'S'.

The while loop executes as long as i/j > 0.0625. The initial values are i = 2.0 and j = 1.0. In each iteration, j is doubled and sum is updated, followed by a printf call.

• Iter 1: j=1, 2/1 > 0.0625. Prints. j becomes 2.
• Iter 2: j=2, 2/2 > 0.0625. Prints. j becomes 4.
• Iter 3: j=4, 2/4 > 0.0625. Prints. j becomes 8.
• Iter 4: j=8, 2/8 > 0.0625. Prints. j becomes 16.
• Iter 5: j=16, 2/16 = 0.125 > 0.0625. Prints. j becomes 32.
• Next check: j=32, 2/32 = 0.0625. The condition 0.0625 > 0.0625 is false. The loop terminates.
  The printf statement is executed 5 times.

The initial values are $i=2.0$, $j=1.0$, and $\sum=0.0$. The loop condition $i/j > 0.001$ is equivalent to $2.0/j > 0.001$, which simplifies to $j < 2000$. In each iteration, $j$ increments by $1$, so the loop executes for initial values of $j=1, 2, \dots, 1999$. When $j$ reaches $2000$, the condition $2.0/2000 > 0.001$ (or $0.001 > 0.001$) becomes false, terminating the loop. Thus, the program executes the loop $1999$ times, generating $1999$ lines of output, which is clearly more than $29$.

The loop iterates while $i < 10$, updating $j = j \cdot i$ and incrementing $i$ in each step.

1. Normal termination: The loop completes $i=1$ through $i=9$, resulting in $j = 1 \cdot 2 \cdot \dots \cdot 9 = 9!$ and $i = 10$.
2. Early termination (break): If $i$ reaches $x$ (where $x \le 10$), the loop terminates with $i=x$ and $j = 1 \cdot 2 \cdot \dots \cdot (x-1) = (x-1)!$.
3. Combining these states: The variable $j$ equals $9!$ when $i \ge 10$ (normal loop completion) or $j$ equals $(x-1)!$ when the loop breaks at $i=x$.
4. This corresponds to the logical condition: $(j=9!) \wedge (i \ge 10) \vee (j=(x-1)!) \wedge (i=x)$.

The loop iterates $i$ from $0$ to $15$, processing bits sequentially from Most Significant Bit (MSB) to Least Significant Bit (LSB). The expression num << i shifts the input num left, effectively moving the bit at position $(15-i)$ to the $15^{th}$ bit position. The mask 1 << 15 (which is $2^{15}$) performs a bitwise AND to isolate this bit; if the result is non-zero, the condition is true. The ternary operator ? 1 : 0 then prints $1$ if the bit is set and $0$ otherwise. Thus, the program prints the binary representation of the $16$-bit integer.

The program's output is determined by tracing the values of the integer variables m, n, and n1.

1. int m = 10;
2. n = ++m; // m is pre-incremented to 11. n is assigned 11.
3. n1 = m++; // n1 is assigned the current value of m (11). m is then post-incremented to 12.
4. n--; // n is post-decremented to 10.
5. --n1; // n1 is pre-decremented to 10.
6. n -= n1; // This is n = n - n1, so n = 10 - 10, which results in n = 0.
   Finally, printf prints the value of n, which is 0.

The expression is 2 - 5 + 1 - 7 * 3. The evaluation depends on the given operator precedence (High: +, Medium: -, Low: *) and associativity (Left: +, *, Right: -).

1. The highest precedence operator is +. We evaluate 5 + 1 first: 2 - 6 - 7 * 3.
2. The next highest is -, which is right-associative. This means a - b - c is evaluated as a - (b - c). So, we evaluate 6 - 7 next: 2 - (-1) * 3.
3. This simplifies to 3 * 3.
4. The final operation is *, resulting in 9.

The C preprocessor performs literal text substitution when expanding macros. When the macro hypotenuse(a+2, b+3) is called, the arguments a+2 and b+3 replace the parameters a and b in the expression $a*a+b*b$.

This results in the expansion:
$a+2*a+2 + b+3*b+3$

Following standard operator precedence, multiplication is evaluated before addition:
$a + (2*a) + 2 + b + (3*b) + 3$

Combining the terms simplifies to:
$3*a + 4*b + 5$

Thus, the final expression evaluated is $\sqrt{3*a+4*b+5}$.

Given $i=6720$ and $j=4$, the loop executes while $i$ is divisible by $j$, updating $i = i/j$ and $j = j+1$ in each step:

1. Iteration 1: $6720 \% 4 = 0 \implies i = 1680, j = 5$.
2. Iteration 2: $1680 \% 5 = 0 \implies i = 336, j = 6$.
3. Iteration 3: $336 \% 6 = 0 \implies i = 56, j = 7$.
4. Iteration 4: $56 \% 7 = 0 \implies i = 8, j = 8$.
5. Iteration 5: $8 \% 8 = 0 \implies i = 1, j = 9$.
6. Final check: $1 \% 9 \neq 0$, the condition fails, and the loop terminates with $j=9$.

The for loop iterates $i$ from $0$ to $9$.
The expression $i \& 1$ computes the bitwise AND of $i$ and $1$, which returns $0$ if $i$ is even and $1$ if $i$ is odd.
For values $i \in \{0, 2, 4, 6, 8\}$, $i \& 1 = 0$.
For values $i \in \{1, 3, 5, 7, 9\}$, $i \& 1 = 1$.
The concatenated result of these operations is $0101010101$.

The statement a[++n] = n++; attempts to modify the variable $n$ twice within a single expression without an intervening sequence point. According to the C and C++ language standards, modifying a variable more than once between two sequence points results in Undefined Behavior (UB). Consequently, the compiler is free to evaluate the left-hand side a[++n] and the right-hand side n++ in any order it chooses, and the side effects may be applied unpredictably. Because the behavior is undefined by the language standard, the result varies based on the specific compiler implementation.

The loop condition is $i/j > 0.001$, which simplifies to $2/j > 0.001$, or $j < 2000$.
$j$ starts at $1.0$ and doubles in each iteration ($j_n = 2^n$ after $n$ iterations).
The loop executes as long as the condition holds at the start of each iteration, meaning the loop runs for $j$ values of $1.0, 2.0, 4.0, \dots, 1024.0$.
For each of these 11 values, the condition $2/j > 0.001$ is true (e.g., for $j=1024.0$, $2/1024 \approx 0.00195 > 0.001$).
In each of these 11 iterations, the printf statement executes, producing 11 lines of output.
After the 11th iteration, $j$ becomes $2048.0$, and the condition $2/2048 \approx 0.000976 > 0.001$ is false, terminating the loop.

The original code performs $y = y + 1$, then $z = x + y$ using the updated $y$, and finally $x = x + 1$, resulting in $z = x + (y + 1)$ with $x$ ultimately becoming $x + 1$.
Option B, z = (x++) + (++y), uses the pre-increment operator ++y to increment $y$ to $y + 1$ before the addition.
It uses the post-increment operator x++ to utilize the current value of $x$ in the addition before incrementing $x$ to $x + 1$.
Both sequences calculate the total as $z = x + (y + 1)$ and leave the variable $x$ incremented by $1$.
Thus, the expression is functionally equivalent to the original sequence of three statements.

The formula for $^nC_3$ is $\frac{n(n-1)(n-2)}{3 \times 2 \times 1} = \frac{n(n-1)(n-2)}{6}$.
When $n$ is large, multiplying all terms $n(n-1)(n-2)$ first can lead to an overflow if the intermediate product exceeds the maximum value an unsigned int can hold.
To avoid overflow, it's better to divide by smaller numbers earlier or in a way that ensures intermediate products remain within the valid range.
Options B and C distribute the divisions. Option B computes $n(n-1)/2$ first, which always results in an integer, and then multiplies by $(n-2)$ and divides by 3.
Option C computes $n(n-1)/3$ first, which might result in a non-integer if $n(n-1)$ is not divisible by 3, leading to truncation errors. Since $n(n-1)$ is always even, dividing by 2 first (as in option B) guarantees an integer, making it more robust against truncation.

The integer literal $0570$ is in octal, which equals $5 \times 8^2 + 7 \times 8^1 + 0 \times 8^0 = 376_{10}$.
Right shifting by 4 bits ($>> 4$) is equivalent to integer division by $2^4=16$, resulting in $\lfloor 376 / 16 \rfloor = 23_{10}$.
Left shifting the result by 6 bits ($<< 6$) is equivalent to multiplication by $2^6=64$, yielding $23 \times 64 = 1472_{10}$.
To convert $1472_{10}$ back to octal for the %o format specifier, we perform successive division by 8: $1472 = 2 \times 8^3 + 7 \times 8^2 + 0 \times 8^1 + 0 \times 8^0$, which is $2700_8$.
Therefore, the program prints the octal value $2700$.

The preprocessor directive #define SQR(x) (x*x) performs simple text substitution. When a = SQR(b+2) is called with $b=4$, the preprocessor expands the expression to a = (b+2 * b+2). Substituting $b=4$, the expression becomes $(4 + 2 \times 4 + 2)$. According to C operator precedence, multiplication is performed before addition, leading to $4 + 8 + 2$. This evaluates to $14$, which is then printed by the program.

The loop runs for $z = 0$ to $4$ (5 iterations).
For $z=0$, $x$ becomes $1$, $y$ becomes $1$; for $z=1$, $x$ becomes $2$, $y$ becomes $2$. In both cases, the condition $(++x > 2) || (++y > 2)$ is false.
At $z=2$, $++x$ evaluates to $3$, which is $> 2$. Due to short-circuiting, $y$ remains $2$, and the if block executes, incrementing $x$ to $4$.
For $z=3$ and $z=4$, $(++x > 2)$ is true, so the if block executes each time, $y$ remains $2$, and $x$ increments by $1$ during each iteration.
Specifically, at $z=3$, $x$ increments to $5$ and then $6$; at $z=4$, $x$ increments to $7$ and then $8$.
Final values are $x = 8$ and $y = 2$, leading to an output of $8 \ 2$.

The code executes a loop for $i \in \{0, 1, 2\}$ evaluating the condition if (a = cos(pi * i / 2)):

1. For $i=0$: $\cos(0) = 1$. The assignment $a = 1$ evaluates to true (non-zero), printing $1$.
2. For $i=1$: $\cos(\frac{\pi}{2}) \approx 0$. Due to floating-point precision, it results in a value extremely close to $0$, which casts to integer $0$. The condition is false, printing $0$.
3. For $i=2$: $\cos(\pi) = -1$. The assignment $a = -1$ evaluates to true (any non-zero value is true in C), printing $1$.

Combining these results, the output is 101.

Initially, the variables are assigned values $y = 10$ and $z = 12$. The expression $x = y++ + z++$ utilizes the post-increment operator, which evaluates the addition using the current values before incrementing the operands. Thus, $x$ is calculated as $10 + 12 = 22$. Following the calculation, both $y$ and $z$ are incremented by 1, resulting in $y = 11$ and $z = 13$. Consequently, the final values are $x = 22$, $y = 11$, and $z = 13$.