Array And Pointer Practice Questions

In C programming, malloc (memory allocation) and calloc (contiguous allocation) are standard library functions designed to request blocks of memory from the heap during program runtime. Static memory allocation occurs at compile-time, where the size and memory location of variables are fixed before execution. Conversely, dynamic memory allocation enables a program to allocate or release memory while the program is running, based on specific, variable requirements. Since these functions allow for runtime memory management via pointers, they are classified as tools for dynamic memory allocation.

The function strlen returns a value of type size_t, which is an unsigned integer.
In the printlength function:

• strlen(s) where s is "abc" returns 3u.
• strlen(t) where t is "defgh" returns 5u.
• The condition in the ternary operator is (strlen(s) - strlen(t)) > c.
• This becomes (3u - 5u) > 0u.
  In unsigned arithmetic, 3u - 5u does not result in -2. Instead, it underflows and wraps around to a very large positive value (e.g., $2^{32}-2$ on a 32-bit system). This large positive value is greater than c (which is 0).
  Since the condition is true, the ternary operator evaluates to its first expression, which is strlen(s).
  The value of strlen(s) is 3, which is assigned to len and then printed.

The function printxy is called with arguments by value, so local variables x and y are created inside the function with initial values of 1.

1. x = 0;: The local variable x is updated to 0.
2. ptr = &x;: The pointer ptr is assigned the memory address of the local x.
3. y = *ptr;: The value at the address ptr (which is the value of x, i.e., 0) is assigned to y. So, y becomes 0.
4. *ptr = 1;: The value at the address ptr is changed to 1. Since ptr points to x, the value of x becomes 1.
   Finally, printf prints the current values of x and y, which are 1 and 0, respectively.

The code suffers from a memory leak. Initially, the pointer x is assigned a memory address by the first malloc call. The program then enters the if block, where x is reassigned to a new memory address from a second malloc call. This reassignment overwrites the address of the first memory block. As there are no other pointers to this first block, it becomes inaccessible and cannot be deallocated. The final free(x) call only releases the second memory block, leaving the first one leaked.

1. Initialize $k = 5$.
2. Declare pointer $p = \&k$, meaning $p$ points to the memory address of $k$. Dereferencing $*p$ yields $5$.
3. Declare double pointer $m = \&p$, meaning $m$ points to the memory address of pointer $p$. Dereferencing $*m$ yields $p$, and double dereferencing $**m$ yields $k$, which is $5$.
4. The printf statement outputs $k$, $*p$, and $**m$, which are all $5$.
5. The final output is $5\ 5\ 5$.

The integer $320$ in hexadecimal is represented as $0x0140$ ($1 \times 256 + 4 \times 16 + 0$).
On a little-endian processor, the bytes of the 2-byte short $a$ are stored in memory from the least significant byte to the most significant byte: $0x40$ is stored at the starting address &a, and $0x01$ is stored at &a + 1.
The char *ptr points to the first byte of $a$, which is $0x40$.
Dereferencing ptr yields the value stored at that address, which is the hexadecimal $0x40$.
Converting $0x40$ to decimal, we get $4 \times 16 + 0 = 64$.
The printf function then outputs this decimal value.

The character array s1 is initialized to "1234". The pointer p is made to point to the third element of s1 (the character '3') by the statement p = s1 + 2;. The next statement, *p = '0';, dereferences the pointer p and changes the value at that memory location to '0'. This modifies the original string s1 to "1204". Finally, printf("%s", s1); prints the entire modified string.

Given the declaration int a, *b=&a, **c=&b;, the variable $b$ holds the address of $a$ ($\&a$), and $c$ holds the address of $b$ ($\&b$).
The statement $a=4;$ assigns the integer value 4 to $a$.
The expression $**c$ performs double dereferencing: dereferencing $c$ yields $b$ (i.e., $*c = b$), and dereferencing $b$ yields $a$ (i.e., $*b = a$).
Consequently, the assignment $**c=5;$ is equivalent to setting $a=5$, which updates the value stored at $a$.
This sequence directly results in assigning 5 to $a$.

Initial array state: $x = \{1, 2, 3, 4, 5, 6, 7, 8\}$.
For $i=2$, $x[x[2]] = x[3] = x[2] = 3$, so the array becomes $\{1, 2, 3, 3, 5, 6, 7, 8\}$.
For $i=3$, $x[x[3]] = x[3] = x[3] = 3$, so the array remains $\{1, 2, 3, 3, 5, 6, 7, 8\}$.
For $i=4$, $x[x[4]] = x[5] = x[4] = 5$, so the array becomes $\{1, 2, 3, 3, 5, 5, 7, 8\}$.
For $i=5$, $x[x[5]] = x[5] = x[5] = 5$, so the array remains $\{1, 2, 3, 3, 5, 5, 7, 8\}$.
The final loop prints the elements of $x$ as $1 2 3 3 5 5 7 8$.

The pointer ptr is initialized to point to the beginning of the array of pointers p. The statement ptr++ increments ptr to point to the second element of p, which is a+3.

1. ptr-p: This calculates the offset of ptr from the beginning of p. Since ptr was incremented once, the result is 1.
2. **ptr: This dereferences ptr twice.
   • *ptr evaluates to the value at the new ptr position, which is the address a+3.
   • **ptr evaluates to the value at the address a+3, which is the fourth element of array a, i.e., 40.
     The program prints 1 and 40.

The variable x is a 2D array int x[4][3] with a base address of 2000. An integer occupies 4 bytes.

1. x+3: x is a pointer to an array of 3 integers. The size of this array is $3 \times 4 = 12$ bytes. x+3 points to the 4th such array, so its address is $2000 + 3 \times 12 = 2036$.
2. *(x+3): This dereferences x+3, yielding the address of the 4th array itself, which is also 2036.
3. *(x+2)+3: *(x+2) is the address of the 3rd array, which is $2000 + 2 \times 12 = 2024$. Adding 3 to this pointer moves it forward by $3 \times 4 = 12$ bytes. The final address is $2024 + 12 = 2036$.
   All three expressions evaluate to 2036.

The main function declares an integer i and a pointer pi that stores the address of i.
scanf("%d", pi) reads an integer from the console and stores it at the memory location pointed to by pi, which is the variable i.
Therefore, i now holds the integer value entered by the user.
printf("%d\n", i + 5) prints the value of i incremented by 5. This means it prints 5 more than the integer value that was entered.

The provided C function ProcessArray uses a do-while loop to repeatedly adjust i and j based on comparisons with listA[k], where k is the midpoint. This iterative narrowing of the search range, [i, j], by comparing x with the middle element, is characteristic of a binary search algorithm. The function aims to find the index k where x is located, or return -1 if x is not found.

The C-program initializes a character array c with "GATE2011" and a character pointer p to c.
The printf statement uses %s to print a string starting from an address.
p[3] refers to the character at index 3 of c, which is 'E'. p[1] refers to the character at index 1, which is 'A'.
In C, when subtracting two pointers of the same type, the result is the number of elements between them. However, here, character values are subtracted, resulting in an integer difference of their ASCII values. Since 'E' - 'A' = 4, the expression p + p[3] - p[1] evaluates to p + 4.
This means the printf function will start printing the string from the memory location p points to, shifted 4 positions forward. The character at index 4 of "GATE2011" is '2', so the output will be "2011".

In Pascal, an array index type must be an ordinal type (e.g., $INTEGER$, $CHAR$, $BOOLEAN$, or enumerated types) which represents a discrete, countable set of values. The $REAL$ type represents floating-point numbers, which are continuous and not discrete. Because $REAL$ is not an ordinal type, it cannot be used to define the index range of an array. Thus, the declaration $var \ a : array \ [REAL] \ of \ REAL;$ is syntactically illegal, while options A, C, and D utilize valid ordinal indices.

The character array $a$ is initialized as $\{'w', 'o', 'r', 'l', 'd', '\0'\}$.
In the first loop iteration ($i=0, j=5$), the code executes $a[0] = a[5]$, setting $a[0]$ to the null terminator $'\0'$.
The array content becomes $['\0', 'o', 'r', 'l', 'd', '\0']$.
The printf function prints the string starting from the first index until it encounters a null terminator.
Since $a[0] = '\0'$, the function encounters the terminator immediately and outputs an empty (null) string.

The program initializes $a$ as a $2 \times 3$ matrix and $b$ as a $3 \times 2$ matrix. The pointer $p$ points to the base address of $b$. The nested loops iterate through $a$ with indices $i \in \{0, 1\}$ and $j \in \{0, 1, 2\}$, assigning $a[i][j]$ to the memory location at $p + 2j + i$.

Because $b$ is a $3 \times 2$ array, the memory offset $2j + i$ corresponds to the row index $j$ and column index $i$. Thus, the assignment effectively performs $b[j][i] = a[i][j]$, which is a matrix transposition:

• For $i=0$: $b[0][0] = 'a'$, $b[1][0] = 'b'$, $b[2][0] = 'c'$
• For $i=1$: $b[0][1] = 'd'$, $b[1][1] = 'e'$, $b[2][1] = 'f'$

The resulting array $b$ is:
$\begin{array}{ll} \mathrm{a} & \mathrm{d} \\ \mathrm{b} & \mathrm{e} \\ \mathrm{c} & \mathrm{f} \end{array}$

The provided binary search implementation uses the update rule $i = k$ when $Y[k] < x$. If the pointers are adjacent (e.g., $i=8$ and $j=9$), the midpoint $k$ is calculated as $\lfloor (8+9)/2 \rfloor = 8$. Since $Y[8] < x$ (as $2 < x$ in option C), the assignment $i = k$ sets $i$ to $8$, which fails to advance the pointer. Consequently, the loop condition $i < j$ remains true and $Y[k] \neq x$ remains true indefinitely, resulting in an infinite loop. Thus, the program fails for option C.