GATE IT 2008 | Question: 52

Question

C program is given below:

# include <stdio.h>
int main ()
{
        int i, j;
        char a [2] [3] = {{'a', 'b', 'c'}, {'d', 'e', 'f'}};
        char b [3] [2];
        char *p = *b;
        for (i = 0; i < 2; i++) {
              for (j = 0; j < 3; j++) {
              *(p + 2*j + i) = a [i] [j];
              }
        }
}

What should be the contents of the array b at the end of the program?

• A. $\text{a    b}$
  $\text{c    d}$
  $\text{e    f}$
   
• B. $\text{a    d}$
  $\text{b    e}$
  $\text{c    f}$
   
• C. $\text{a    c}$
  $\text{e    b}$
  $\text{d    f}$
   
• D. $\text{a    e}$
  $\text{d    c}$
  $\text{b    f}$

Comments

Approach:

*b points to individual elements of the 1d array.

*(p+0+0) = b[0][0] = a

*(p+2+0) = b[1][0] = b

*(p+4+0) = b[2][0] = c

---

Understanding `char *p = *b;`

Given the declaration:
```c
char b[2][3];
char *p = *b;
```
Let's break it down step by step.

---

1. Understanding `b[2][3]`
   - `b` is a **2D character array** with 2 rows and 3 columns.
   - It is essentially stored as:
     ```
     b[0][0]  b[0][1]  b[0][2]
     b[1][0]  b[1][1]  b[1][2]
     ```
   - In **memory**, it is stored **row-wise (contiguously)**.

2. What is `b`?
   - `b` is an array of `2` elements, where each element is an array of `3` characters.
   - `b` **decays into** a pointer to its first row, i.e., `b` is of type `char (*)[3]`, which means "pointer to an array of 3 characters."

3. What is `*b`?
   - Since `b` is of type `char (*)[3]` (pointer to an array of 3 characters),
     - `*b` **dereferences this pointer**, giving us **the first row** of the 2D array:
       ```c
       *b == b[0]  // Points to first row (first element of first row)
       ```
     - `*b` is of type `char[3]` (array of 3 characters).
     - But in expressions, an array **decays** into a pointer to its first element.
       - So, `*b` **decays into** a pointer to `b[0][0]`, i.e., the first element.

4. What does `p = *b;` mean?
   - Since `*b` is `b[0]`, which decays into `&b[0][0]`,
   - `p` is assigned the address of `b[0][0]`.

Final Answer:
✅ `p` holds the **address of `b[0][0]`**, i.e.,
   ```c
   p == &b[0][0];
   ```

---

Example Program:
```c
#include <stdio.h>

int main() {
    char b[2][3] = {{'a', 'b', 'c'}, {'d', 'e', 'f'}};
    char *p = *b;  // Equivalent to p = &b[0][0];

    printf("p points to: %c\n", *p);       // Output: 'a'
    printf("Next value: %c\n", *(p + 1));  // Output: 'b'
    printf("Next value: %c\n", *(p + 2));  // Output: 'c'
    printf("Next value: %c\n", *(p + 3));  // Output: 'd' (next row)
    
    return 0;
}
```

Key Takeaways:
- `b` is a **pointer to an array** (`char (*)[3]`).
- `*b` gives us `b[0]`, which **decays** into `&b[0][0]`.
- `p = *b;` makes `p` point to `b[0][0]`, treating the 2D array as a **1D contiguous block**.

---

just do one think, goto any LLM and ask it to teach you 

" pointer decay "

Answer 1

The correct answer is option (B).

first integer type two variables declared $i$ and $j$

then an integer type $2-d$ array $a[2][3]$ is declared and initialized and $2-d$ array $b[3][2]$ is created but not initialized. i.e 

            address     value                       address         value

$a[0][0]$   $2000$         $a$               $b[0][0]$   $3000$          garbage value

$a[0][1]$   $2001$         $b$               $b[0][1]$   $3001$          garbage value

$a[0][2]$   $2002$         $c$               $b[1][0]$   $3002$          garbage value

$a[1][0]$   $2003$         $d$               $b[1][1]$   $3003$          garbage value

$a[1][1]$   $2004$         $e$               $b[2][0]$   $3004$          garbage value

$a[1][2]$   $2005$         $f$                $b[2][1]$   $3005$          garbage value

now the char type pointer is declared and the base address of  array  $b$ is put in it. so $p=3000$

now the for loop is started where $i$ is initialized to $0$ ,so 

$i=0 : i<2$ (true)

      $j=0; j<3$ (true)

          $*(3000+2*0+0) =a [0][0]  \Rightarrow *(3000) = a$

            $j++$ 

         $j=1; j<3$ (true)

         $ *(3000+2*1+0) =a [0][1]  \Rightarrow *(3002) = b$

           $ j++$

         $j=2; j<3$ (true)

          $*(3000+2*2+0) =a [0][2]  \Rightarrow  *(3004) = c$

           $ j++$

         $j=3; j<3$ (false)

    $i++$

$i=1 : i<2$ (true)

       $j=0; j<3$ (true)

          $*(3000+2*0+1) =a [1][0]  \Rightarrow *(3001) = d$

            $j++$ 

         $j=1; j<3$ (true)

          $*(3000+2*1+1) =a [1][1]  \Rightarrow *(3003) = e$

            $j++$

         $j=2; j<3$ (true)

         $ *(3000+2*2+1) =a [1][2]  \Rightarrow  *(3005) = f$

            $j++$

         $j=3; j<3$ (false)

    $i++$

now the values in array $b$ is 

 $b[0][0]$   $3000$           $a$

 $b[0][1]$   $3001$           $d$

 $b[1][0]$   $3002$           $b$

 $b[1][1]$   $3003$           $e$

 $b[2][0]$   $3004$           $c$

 $b[2][1]$   $3005$           $f$

Hence, the output will be (B) choice.

Note:

*(p + 2*j + i)

$p +$ size of inner dimension $* j + i$, hence is same as $p[j][i]$. Hence with this statement we can identify that the code is transposing the matrix $a$ and storing in $b$ using pointer $p$. 

Comments

@Bibhu Pala here p is a character pointer pointing to individual cells of b 2d array. Please note that *p=*b and not **p=b.

b points to individual 1D arrays.

*b points to individual elements of the 1d array.

**b is the data present in one of the cell of 1d array.

---

*(p + 2*j + i)

p+ size of inner dimension ∗j+i, hence is same as p[j][i]. Hence with this statement we can identify that the code is transposing the matrix a and storing in b using pointer p. 

Can someone pls elaborate it more?

---

Say a = 2;

a + 1 = 2+1 = 3,   if a is an int

a + 1 = 2 + 1 * sizeof(*a),   if a is a pointer

Answer 2

Both will behave similarly.

$char *p=b$

$char *p=*b$

---

But $char *p=b+1\ \&\ char*p=*b+1$ will behave differently.

Comments

But char∗p=b+1 & char∗p=∗b+1char∗p=b+1 & char∗p=∗b+1 will behave differently.

Wouldn’t first part will give you the error ? as ‘b’ is an array name so it holds the address of the first element of an array , which here is a 1-d array of size 2. So first option should be like this :

char (*p)[2] = b + 1 ; 

Edit : It works but gives a warning : initialization from incompatible pointer type 

Answer 3

For people getting option D

The most important point to remember for all future aspirants - 

char *p = *b

MISTAKE - 

b points to the base address (and hence the whole first row) of array b. So doing p+2 Means you would point p to the LAST row in the result array, which would now contain the element "b".

This Means you would get the answer as Option D.

But *b points to the first element - NOT the entire first row.

So doing *(p+2) would give the element "c" in the second iteration.

Answer 4

char b[3][2]. The second number (2) is the width (columns).

char *p = *b $\Rightarrow$ Pointer *p starts at the first seat of matrix b.

\[
*(p + 2j + i) \quad \text{means } 2 \text{ is the width of } b
\]

In C, the variable multiplied by the width is the Row

Remember:
\[
(\text{Width} \times \text{Index}_1 + \text{Index}_2) \;\Rightarrow\; \text{Index}_1 \text{ is the Row.}
\]

So:
\[
*(p + 2j + i) = a[i][j]
\]
and since the coefficient of $j$ is the width (2),  
\[
2j + i \;\Rightarrow\; j \text{ is the Row of } b.
\]

Therefore:
\[
a[i][j] \text{ moves to } b[j][i].
\]

Basically: $i,j \to j,i$ $\Rightarrow$ Transpose

 

Hence:

     Row 1 of $a$ $(a, b, c)$ $\Rightarrow$ Column 1 of $b$
     Row 2 of $a$ $(d, e, f)$ $\Rightarrow$ Column 2 of $b$

Option B = Correct

 

 

Answer 5

https://youtu.be/zy-ZIzRduSo?si=Lp197Muj-ctQJaVG
video solution for this question