Multi-dimensional arrays: Exercises — Coding deep dive

Before we start, one picture of the flat memory so every "skip 4 boxes" below has something to point at.

The grey number under each box is its linear position (how many elements from the base). That linear position is exactly the value of $i \cdot C + j$ . Keep this strip in mind — every address problem is just "which box number?".

L1 — Recognition

Exercise 1.1 (L1)

For the declaration int a[3][4];, answer without arithmetic: (a) How many ints in total? (b) What is the type of a[i]? (c) What is the type of a[i][j]?

Recall Solution 1.1

(a) $3 \times 4 = 12$ ints. (b) a[i] is "array of 4 ints" — written int[4]. Why? a is an array of 3 things, and each thing is a row of 4 ints. (c) a[i][j] is a single int.

This is the "array of arrays" idea from C Arrays (1D): peel one subscript, drop one dimension.

Exercise 1.2 (L1)

True or false: to compute the address of a[i][j] the compiler needs the row count $R$ .

Recall Solution 1.2

False. Look at the formula: $base + (i \cdot C + j) \cdot s$ . Only $C$ appears; $R$ never does. That is why you may omit the first dimension but not the others.

Exercise 1.3 (L1)

Rewrite a[2][1] using only the * (dereference) operator and +.

Recall Solution 1.3

$a [2] [1] \equiv * (* (a + 2) + 1)$ From Pointers in C: a[i] means *(a+i), applied twice.

L2 — Application

Exercise 2.1 (L2)

int a[3][4]; with base = 2000 and sizeof(int) = 4. Find &a[1][3] (the byte address).

Recall Solution 2.1

$i = 1, j = 3, C = 4, s = 4$ .
elements skipped $= i \cdot C + j = 1 \cdot 4 + 3 = 7$ .
bytes $= 7 \cdot 4 = 28$ .
address $= 2000 + 28 = 2028$ .

On the strip figure, box 7 sits at the start of the second row's last cell — exactly where a[1][3] lives.

Exercise 2.2 (L2)

char c[5][6]; with base = 100, sizeof(char) = 1. Find &c[3][2].

Recall Solution 2.2

$i = 3, j = 2, C = 6, s = 1$ .
skipped $= 3 \cdot 6 + 2 = 20$ .
bytes $= 20 \cdot 1 = 20$ .
address $= 100 + 20 = 120$ .

Note $C = 6$ here, not the number of rows (5). We used the column count, always.

Exercise 2.3 (L2)

Given int m[2][3] = {10, 20, 30, 40, 50, 60};, what is m[1][2]?

Recall Solution 2.3

A flat initializer fills in row-major order:

Row 0 gets {10, 20, 30}
Row 1 gets {40, 50, 60} So m[1][2] = third element of row 1 = 60.

L3 — Analysis

Exercise 3.1 (L3)

int a[3][4]; with base = 1000, sizeof(int) = 4. Compute a + 1, a[0] + 1, and &a[0][0] + 1 as byte addresses. Explain why two of them differ.

Recall Solution 3.1

a decays to int (*)[4] — a pointer to a row of 4 ints. Adding 1 jumps one whole row $= 4 \cdot 4 = 16$ bytes. $\Rightarrow$ a + 1 = $1000 + 16 = 1016$ .
a[0] is int[4], which decays to int*. Adding 1 jumps one int $= 4$ bytes. $\Rightarrow$ a[0] + 1 = $1000 + 4 = 1004$ .
&a[0][0] is int*. Adding 1 jumps one int $= 4$ bytes. $\Rightarrow$ &a[0][0] + 1 = $1000 + 4 = 1004$ .

Why the difference: all three point at the same byte (1000), but their types differ, so "+1" means different distances. This is the heart of Array Decay and Pointer to Array vs Array of Pointers — pointer arithmetic scales by the pointed-to type's size.

Exercise 3.2 (L3)

int a[3][5]; with base = 4000, sizeof(int) = 4. Find the linear index and byte address of a[2][4] (the last element). Then confirm it is the last by counting total elements.

Recall Solution 3.2

$C = 5$ , so linear index $= 2 \cdot 5 + 4 = 14$ .
byte address $= 4000 + 14 \cdot 4 = 4000 + 56 = 4056$ .
Total elements $= 3 \cdot 5 = 15$ , indices $0 \dots 14$ . Index 14 is indeed the last, so a[2][4] is the final element. ✔

Exercise 3.3 (L3)

sizeof reasoning. For int a[3][4] with sizeof(int)=4, give (a) sizeof(a), (b) sizeof(a[0]), (c) sizeof(a[0][0]).

Recall Solution 3.3

(a) sizeof(a) = whole array = $3 \cdot 4 \cdot 4 = 48$ bytes.
(b) sizeof(a[0]) = one row of 4 ints = $4 \cdot 4 = 16$ bytes.
(c) sizeof(a[0][0]) = one int = $4$ bytes.

See sizeof Operator: sizeof reports the type's size, and the type shrinks by one dimension each subscript.

L4 — Synthesis

Exercise 4.1 (L4)

Generalize to 3D. int a[2][3][4] with base = 0, sizeof(int) = 4. Find the byte address of a[1][2][3].

Recall Solution 4.1

Dimensions $X = 2, Y = 3, Z = 4$ . Each index is multiplied by the product of all dimensions to its right:

$i = 1$ multiplies $Y \cdot Z = 3 \cdot 4 = 12$ .
$j = 2$ multiplies $Z = 4$ .
$k = 3$ multiplies $1$ .
linear index $= 1 \cdot 12 + 2 \cdot 4 + 3 = 12 + 8 + 3 = 23$ .
byte address $= 0 + 23 \cdot 4 = 92$ .

Sanity check: total elements $= 2 \cdot 3 \cdot 4 = 24$ , indices $0 \dots 23$ ; a[1][2][3] is the last element → index 23. ✔

Exercise 4.2 (L4)

Write a correct function int sum2d(int rows, int cols, int a[][/*?*/]) that sums any 2D int array — using a VLA parameter (C99) so it works for any column count. Explain why a plain int a[][] would not compile.

Recall Solution 4.1

// VLA parameter: cols is a runtime value that fixes the inner dimension.
int sum2d(int rows, int cols, int a[rows][cols]) {
    int total = 0;
    for (int i = 0; i < rows; i++)
        for (int j = 0; j < cols; j++)
            total += a[i][j];
    return total;
}

Why int a[][] fails: inside the loop the compiler computes a[i][j] via i*cols + j. Without cols it cannot do the i*cols step. So the inner dimension must be known — here we make it a runtime parameter via a VLA. See also Array Decay: a arrives as int (*)[cols].

Exercise 4.3 (L4)

A 2D array int a[R][C] is stored column-major instead (Fortran/MATLAB style). Derive the address formula and compute the linear index of a[2][1] for R=3, C=4.

Recall Solution 4.3

Column-major stores all of column 0, then all of column 1, etc. To reach column $j$ we skip $j$ full columns, each with $R$ elements $\Rightarrow j \cdot R$ . Then move $i$ down inside the column. $addr = base + (j \cdot R + i) \cdot s$ For a[2][1], $R = 3$ : linear index $= 1 \cdot 3 + 2 = 5$ . Compare row-major for the same element: $2 \cdot 4 + 1 = 9$ . Different box! That is exactly the Row-major vs Column-major distinction — same logical element, different physical slot.

L5 — Mastery

Exercise 5.1 (L5)

Inverse problem. int a[3][4] (row-major, sizeof(int)=4) with base = 5000. You are told an element sits at byte address 5040. Recover its [i][j] indices.

Recall Solution 5.1

Offset in bytes $= 5040 - 5000 = 40$ .
Linear index $= 40/4 = 10$ .
Now invert $i \cdot C + j = 10$ with $C = 4$ :
- $i = ⌊ 10/4 ⌋ = 2$ (integer division — how many full rows fit).
- $j = 10 mod 4 = 2$ (the remainder — position inside the row).
Element is $a [2] [2]$ .

Why divide and mod? Row-major packs $C$ elements per row, so dividing the linear index by $C$ counts complete rows (that's $i$ ), and the remainder is how far into the current row you are (that's $j$ ). This is the exact inverse of $i \cdot C + j$ .

Exercise 5.2 (L5)

Design + verify. You want to store a $2 \times 2 \times 2$ RGB-less brightness cube int b[2][2][2] and fill it so that every element equals its own linear index ( $0$ through $7$ ). Write the fill loop, then state the value of b[1][0][1] and prove it equals the address-formula prediction.

Recall Solution 5.2

int b[2][2][2];
for (int i = 0; i < 2; i++)
  for (int j = 0; j < 2; j++)
    for (int k = 0; k < 2; k++)
      b[i][j][k] = i*(2*2) + j*2 + k;   // = linear index, YZ=4, Z=2

For b[1][0][1]: linear index $= 1 \cdot 4 + 0 \cdot 2 + 1 = 5$ , so b[1][0][1] == 5. Proof it matches storage: with base=0, sizeof(int)=4, the byte address is $(1 \cdot 4 + 0 \cdot 2 + 1) \cdot 4 = 5 \cdot 4 = 20$ , i.e. slot 5 on the flat strip — exactly the value we stored. The fill formula is the address formula (without the $\times s$ ), so value and position agree by construction.

Exercise 5.3 (L5)

Full synthesis. Prove the parent note's claim: for T a[R][C], a[i][j] and *(*(a+i)+j) reference the same element. Do it by tracking types and byte offsets, with $R = 3, C = 4$ , sizeof(int)=4, base=B.

Recall Solution 5.3

Follow *(*(a+i)+j) from the inside out:

a decays to int(*)[4] (pointer to a 4-int row), pointing at byte $B$ .
a + i: adds $i$ rows. Each row is $4 \cdot 4 = 16$ bytes, so this points at byte $B + 16 i = B + (i \cdot 4) \cdot 4$ .
*(a+i): dereference gives the row int[4], which decays to int* still at byte $B + 16 i$ .
+ j: adds $j$ ints $= 4 j$ bytes → byte $B + 16 i + 4 j$ .
outer *: read the int at byte $B + 16 i + 4 j$ .

Now the subscript form via the address formula: $addr (a [i] [j]) = B + (i \cdot C + j) \cdot s = B + (4 i + j) \cdot 4 = B + 16 i + 4 j .$ Same byte, same type (int). Therefore a[i][j] ≡ *(*(a+i)+j). The two-step pointer walk is the row-major arithmetic in disguise. ∎

Recall One-line recap of every formula used

Row-major 2D ::: $base + (i C + j) s$ Column-major 2D ::: $base + (j R + i) s$ 3D row-major ::: $base + (i Y Z + j Z + k) s$ Invert linear index ::: $i = idx / C$ , $j = idx mod C$

Connections

Parent: Multi-dimensional Arrays — the theory these drills exercise.
C Arrays (1D) · Pointers in C · Array Decay · Pointer to Array vs Array of Pointers · sizeof Operator · Row-major vs Column-major · Variable Length Arrays (C99)
5.1.11 Multi-dimensional arrays (Hinglish)