Array And Pointer Practice Questions

To find the value printed, we trace the loop with $a = \{2, -2, -1, 3, 4, 2\}$ and $n = 6$:

1. $i = 0, a[0] = 2$: Condition i == 0 is true. maxsum = max(0, 0) = 0, sum = 2.
2. $i = 1, a[1] = -2$: Condition a[1] < 0 is true. maxsum = max(2, 0) = 2, sum = 0.
3. $i = 2, a[2] = -1$: Condition a[2] < 0 is true. maxsum = max(2, 0) = 2, sum = 0.
4. $i = 3, a[3] = 3$: Condition false (as $3 \nless 0$ and $3 \nless -1$). sum = 0 + 3 = 3.
5. $i = 4, a[4] = 4$: Condition false (as $4 \nless 0$ and $4 \nless 3$). sum = 3 + 4 = 7.
6. $i = 5, a[5] = 2$: Condition a[5] < a[4] ($2 < 4$) is true. maxsum = max(7, 2) = 7, `sum = 2$.

After the loop, the final check if (sum > maxsum) ($2 > 7$) is false. Thus, the program prints $7$.

The array st is initialized with structures containing an integer and a string pointer. After p += 1, $p$ points to $st[1]$ ({4, "better"}). The operation ++p -> c increments the pointer to the string "better", causing it to point to "etter". The expression printf("%s,", p++ -> c) prints "etter," and then increments $p$ to point to $st[2]$ ({6, "jungle"}). Next, printf("%c,", *++p -> c) increments the string pointer in $st[2]$ from "jungle" to "ungle" and dereferences it to print the character 'u' followed by a comma. Finally, printf("%d,", p[0].i) prints the integer value 6, and printf("%s \n", p -> c) prints the string "ungle".

To find the output of the program, we trace the execution step-by-step:

1. printf("%d,", a[0][2]);: a[0] initially points to a1. a1[2] is $8$.
2. printf("%d,", *a[2]);: a[2] points to a3. *a3 is the first element of a3, which is $-12$.
3. printf("%d,", *++a[0]);: a[0] (which is x[0]) is incremented to point to a1[1]. The dereferenced value is $7$. Note: x[0] now points to &a1[1].
4. printf("%d,", *(++a)[0]);: a is incremented to point to x[1] (which is a2). a[0] (now x[1]) is a2, and *a2 is $23$.
5. printf("%d\n", a[-1][+1]);: Since a currently points to &x[1], a[-1] is x[0]. We previously modified x[0] to point to &a1[1]. Thus, a[-1][+1] is *( (a1+1) + 1 ), which is a1[2], resulting in $8$.

The printed sequence is $8, -12, 7, 23, 8$.

To check if two strings are anagrams, their character frequencies must cancel each other out. We increment the count for each character in string a and decrement the count for each character in string b. The while loop processes both strings at the same index $j$ until a null terminator is reached. Statement A must increment the frequency of $a[j]$, and statement B must decrement the frequency of $b[j]$ while ensuring the index $j$ is updated for the next iteration. Option D, $A: count[a[j]]++$ and $B: count[b[j++]]--$, correctly accesses $a[j]$ and $b[j]$, then uses the post-increment operator $j++$ to advance the index after accessing $b[j]$, ensuring both strings are processed correctly.

To find two integers with a difference of $S$ in a sorted array, we use the two-pointer technique. Let the difference be $D = a[j] - a[i]$. If $D < S$, the difference is too small, so we must increase $a[j]$ by incrementing $j$ to potentially reach $S$. If $D > S$, the difference is too large, so we must increase $a[i]$ by incrementing $i$ to reduce the difference. The given algorithm executes j++ when $E$ is true and i++ when $a[j] - a[i] > S$. Therefore, $E$ must correspond to the condition $a[j] - a[i] < S$.

The transpose of a matrix $M$ is defined by swapping elements $M[i][j]$ and $M[j][i]$. If the inner loop iterates $j$ from $0$ to $3$ for every $i$, every non-diagonal pair $(i, j)$ is swapped twice, restoring the original matrix. To perform a valid transpose, we must swap only the elements where $j \ge i$ (the upper triangle including the diagonal). The correct swapping logic requires a temporary variable $t$ to hold $M[i][j]$ before assigning $M[j][i]$ to $M[i][j]$ and $t$ to $M[j][i]$. Option C correctly implements the loop $j = i$ to $j < 4$ and the required swap sequence.

Given $s = \text{"string"}$, the length is $6$, and index $s[6]$ corresponds to the null terminator $'\0'$.
The loop runs for $i = 0$ to $i = 5$.
At the first iteration ($i = 0$), the statement $p[i] = s[\text{length} - i]$ executes as $p[0] = s[6] = '\0'$.
Since the first character of the array $p$ is assigned the null terminator $'\0'$, $p$ is interpreted as an empty string.
When printf("%s", p) is called, it encounters $p[0] = '\0'$ immediately, resulting in no output being printed.

The variable $A[j]$ remains $0$ if and only if $j \pmod k = 0$ for all $k$ in the range $[2, L]$, where $L = 2\lceil \log_2 n \rceil$.
This condition requires $j$ to be a multiple of the least common multiple of all integers from $2$ to $L$, denoted by $\text{lcm}(2, 3, \dots, L)$.
For any $n \geq 3$, the lower bound $L = 2\lceil \log_2 n \rceil$ is at least $4$.
Since $\text{lcm}(2, 3, \dots, L) \geq \text{lcm}(2, 3, 4) = 12$, and for $n \geq 3$, $\text{lcm}(2, 3, \dots, L) > n$, no integer $j$ in the range $[3, n]$ can satisfy the condition $j \pmod k = 0$ for all $k \in [2, L]$.
Thus, $A[j]$ is set to $1$ for all $j \in [3, n]$, and the set of printed numbers is empty.

The variable $A$ is an array of pointers (int *A[10]), and $B$ is a 2D array (int B[10][10]).

1. Expression $A[2]$ is of type $\int *$, which is an assignable lvalue; hence, I is valid.
2. Expression $A[2][3]$ is of type $\int$ (the result of dereferencing a pointer), which is an assignable lvalue; hence, II is valid.
3. Expression $B[1]$ is of type $\int [10]$, an array identifier. In C, array names are not modifiable lvalues and cannot be used on the left side of an assignment; hence, III is invalid.
4. Expression $B[2][3]$ is an $\int$ element of the 2D array, which is an assignable lvalue; hence, IV is valid.
   Since I, II, and IV are valid lvalues, they will not result in compile-time errors.

The structure contains an array $x$ of 5 $short$ elements and a union $u$.
The size of array $x$ is calculated as $5 \times \text{sizeof(short)} = 5 \times 2 = 10$ bytes.
The union $u$ contains a $float$ (4 bytes) and a $long$ (8 bytes); the size of a union is the maximum of its members' sizes, so $\text{sizeof(u)} = \max(4, 8) = 8$ bytes.
Ignoring alignment, the total memory requirement for the structure $t$ is the sum of the sizes of its members: $\text{sizeof(t)} = \text{sizeof(x)} + \text{sizeof(u)} = 10 + 8 = 18$ bytes.

X: The operation m = malloc(5); m = NULL; causes the pointer m to lose the address of the dynamically allocated memory, resulting in a memory leak, which is lost memory (X-3).
Y: free(n) deallocates the memory at n, making n a dangling pointer; attempting to access n -> value leads to using dangling pointers (Y-1).
Z: The declaration char *p followed by *p = 'a' attempts to write data to an address p that has not been initialized to point to valid memory, which is using uninitialized pointers (Z-2).
Therefore, the correct mapping is X-3, Y-1, and Z-2.

The declaration struct node { int i; float j; }; establishes node as a user-defined structure type.
In the expression struct node *s[10];, the array subscript operator [] possesses higher precedence than the pointer operator *.
Consequently, the compiler interprets s as an identifier for an array containing $10$ elements.
The type associated with each element is struct node *, which represents a pointer to an object of type node.
Thus, $s$ is an array where each of the $10$ elements is a pointer to a structure of type node.

Aliasing occurs in programming when multiple symbolic names (e.g., $p$ and $q$) refer to the same physical memory address. For instance, if $p = \&x$ and $q = \&x$, both variables point to the exact storage location of $x$. Consequently, modifying the data at memory address $x$ through $p$ is immediately reflected when accessing the value via $q$. This phenomenon is strictly defined by the sharing of a memory location, rather than merely holding identical values in separate memory addresses. Therefore, aliasing is characterized by multiple variables sharing the same memory location.