GATE CSE 2021 | Set 2 | Question: 10

Question

Consider the following $\text{ANSI C}$ program.

#include <stdio.h>
int main() 
{
    int arr[4][5];
    int  i, j;
    for (i=0; i<4; i++) 
    ​​​​​​{
        for (j=0; j<5; j++) 
        {
            arr[i][j] = 10 * i + j;
        }
    }
    printf(“%d”, *(arr[1]+9));
    return 0;
}

What is the output of the above program?

• A. $14$
• B. $20$
• C. $24$
• D. $30$

Comments

The 2d array in itself is the array of elements accessed in row major order.

---

\begin{equation}
    \texttt{We know that: arr[1] = *(arr + 1),}
\end{equation}

\begin{align*}
    \texttt{*(arr[1] + 9)} & = \texttt{*( *(arr + 1) + 9 )} \\
    & = \texttt{*( ({starting address of 1st row}) + (9 x {sizeof(int)}) )} \\
    & = \text{Value stored at the computed address} \\
    & = 24
\end{align*}

---

As taught By Amit Khurana Sir,

 

The array is initialized as

\[

\begin{array}{ccccc}

0 & 1 & 2 & 3 & 4 \\

10 & 11 & 12 & 13 & 14 \\

20 & 21 & 22 & 23 & 24 \\

30 & 31 & 32 & 33 & 34

\end{array}

\]

The expression

*(arr[1] + 9)

can be analyzed as follows:

• arr[1] is equivalent to *(arr + 1).
• arr points to the first row of the 2D array. Hence, arr + 1 points to the second row.
• Therefore, arr[1] is a pointer to the first element of the second row, i.e., &arr[1][0].

Since a 2D array is stored in row-major order, its memory layout is

\[

\begin{array}{cccccccccccccccccccc}

0 & 1 & 2 & 3 & 4 &

10 & 11 & 12 & 13 & 14 &

20 & 21 & 22 & 23 & 24 &

30 & 31 & 32 & 33 & 34

\end{array}

\]

Now,

arr[1] + 9

moves the pointer 9 integer locations ahead from arr[1][0].

The traversal is

\[

10 \rightarrow 11 \rightarrow 12 \rightarrow 13 \rightarrow 14 \rightarrow 20 \rightarrow 21 \rightarrow 22 \rightarrow 23 \rightarrow 24

\]

Thus,

\[

arr[1] + 9 = \&arr[2][4]

\]

and therefore,

\[

*(arr[1] + 9) = arr[2][4] = 24.

\]

Hence, the output is

\[

\boxed{24}

\]

Answer: (C) 24

Answer 1

$arr[1]+9$

$arr[1]$ is a pointer to 1D array of $5$ integers and so the above expression involves pointer arithmetic.

For a pointer value $p$ and integer value $d,$

• $p + d \implies p + sizeof(*p) + d $

So,

arr[1]+9 = *(arr+1) + 9 //arr is again a pointer but to the 2D array arr[4][5]

arr+1 = arr + sizeof(*arr)
      = arr + 5 * sizeof (int)
     
*(arr+1)+9 = arr + 5 * sizeof(int) + sizeof(**arr) * 9
//* operator in *(arr+1) just changes the type of the pointer here
        = arr + 5 * sizeof(int) + 9 * sizeof(int)
        = arr + 14 * sizeof(int)

Now, C language follows row major ordering for arrays which means that when a multi dimensional array gets linearized in memory the lower dimensions get arranged contiguously. For the 2D array $arr[4][5]$ it’ll be 

$5$ elements of $arr[0][5]$ followed by $5$ elements of $arr[1][5]$ followed by $5$ elements of $arr[2][5]$ and so on.

So, the $14^{th}$ element will be at row number $\lfloor 14/5 \rfloor = 2$ and column number $14\%5 =4,$ which is $arr[2][4] = 10\times 2+4 = 24.$ 

More Read: https://gatecse.in/chapter-3-pointers/

Comments

You can add a for loop like below to go through all the element which are being parsed like

printf(“%d”, *(arr[1]+9));

---

Use pythontutor for understanding code:  pythontutor.com/c.html#mode=edit

---

Here’s the code  : 

#include <stdio.h>

int main()
{
    int arr[4] [5] ;

    int i, j, k;

    for (i=0; i<4; i++) { 
        for (j=0; j<5; j++){ 
            arr[i][j] = 10*i + j;
        }
    }
  
    for(k=0; k<12; k++){
      printf("%d ", *(arr[1]+k));
    }
    
    printf ("%d", *(arr[1] + 9) );

    return 0;
}

 

---

[0,0],[0,1],[1,2],[1,3],[1,4],[2,0]...[2,4],[3,0]...[3,4],[0,0].

for *(a[1]+9)

arr[2,4]=10*2+4=24

for *(a[1]+15)

arr[0,0]=10*0+0=0

---

I think instead of,

                    $p + d \Rightarrow  p + sizeof(*p) + d$

It would be,

                    $p+d \Rightarrow p + sizeof(*p) * d$

 

Source: The C Programming Language, Ritchie & Kernighan

As we can see here, "n is scaled" is mentioned.

 

---

@Gopal6854 Yeah, I was wondering about that too. Thanks!

Answer 2

We know that a[4][5] is a 2D matrix which has 4 rows and 5 columns,

Logical representation: 

[0][0]  [0][1]  [0][2]  [0][3]  [0][4]

[1][0]  [1][1]  [1][2]  [1][3]  [1][4]

[2][0]  [2][1]  [2][2]  [2][3]  [2][4]

[3][0]  [3][1]  [3][2]  [3][3]  [3][4]

In memory:

(All multi-dimensional arrays in C get linearized in memory row by row as C standard mandated row major ordering for arrays)

[0][0]  [0][1]  [0][2]  [0][3]  [0][4]  [1][0]  [1][1]  [1][2]  [1][3]  [1][4]  [2][0]  [2][1]  [2][2]  [2][3]  [2][4]  [3][0]  [3][1]  [3][2]  [3][3]  [3][4]

Let’s understand what *(a[1]+9) means:

It’s nothing but value at a[1][9] i.e value at 1st row 9th col. Now, we are not able to find this index that’ll be our next question. Since C doesn’t check for array index range it searches in row-major order so, we need to start from a[1][0] and move to 9th place from here in memory ([1][1] will be your 1st jump).

So, 9th place is [2][4] i.e [1][9] = [2][4]

Hence, 10 * 2 + 4 = 24 (Option C)

Comments

why a[1][1] will be the starting index?

shouldn’t it be a[1][0]?

---

Yes, a[1][0] will be your start position/index and in the above comment what I meant is a[1][1] will be your 1^st step/jump from a[1][0]. Hope this clarifies your doubt.

---

so basically 15^th element, in above answers, it was confusing that which element no. everybody wrote 14^th element, which will be 2,3 or 23. but now I got it. 

---

This made more sense than the most upvoted one !

Answer 3

*(arr[1]+9) = arr[1][9]

but arr declared as int arr[4][5], due to C doesn’t check array index range and follow row major order

arr[1][5] = arr[2][0]

arr[1][6] = arr[2][1]

arr[1][7] = arr[2][2]

arr[1][8] = arr[2][3]

arr[1][9] = arr[2][4]

 

arr[2][4] = 10*i + j = 10*2+4 = 24

Option C is the answer.

Comments

Sir,

How it's started from arr[1][5]

And

How arr[1][5] =  arr[2][0]

Please explain where I am missing

---

Draw Table by yourself

---

Do they want to check the memory layout concept with this question?

Answer 4

After the for loop, the arr[4][5] will look like below table

arr[4][5]

0	1	2	3	4
10	11	12	13	14
20	21	22	23	24
30	31	32	33	34

Now *(arr[1]+9) can be translated as: *(*(arr+1)+9)
Now step by step resolving it:

arr[4][5]

0	1	2	3	4
10 *(arr[1]+0)	11 *(arr[1]+1)	12 *(arr[1]+2)	13 *(arr[1]+3)	14 *(arr[1]+4)
20 *(arr[1]+5)	21 *(arr[1]+6)	22 *(arr[1]+7)	23 *(arr[1]+8)	24 *(arr[1]+9)
30	31	32	33	34

Hence C. 24 is the answer.

Answer 5

If you the know the subtle difference between (a+1) and *(a+1) this can be solved within 30 seconds.

(a+1) → points to the entire 2^nd row. It is a pointer to an integer array of size 5.

*(a+1) → points to the 1^st element of the 2^nd row. It is a pointer to an integer.

Now *(arr[1] + 9) can be interpreted as *(*(arr +1) + 9)

  → Which means we need to go to the 2^nd row and access the 9^th element from the starting of the 2^nd Row which is finally arr[2][4] = 10 * 2 + 4 = 24

To understand please refer to the diagram below:

 

 

 

 

 

 

 

 

Solution : Option (C)

Answer 6

Answer id $(C)$. Its $arr[2][4] = 10*2 + 4 = 24$