AP Computer Science A:: 2D Array

What is a 2D (two-dimensional) ARRAY in Java?

- **A)** An array that can only store exactly 2 elements
- **B)** An array of arrays -- conceptually a grid/table of values organized into ROWS and COLUMNS, accessed using TWO indices
- **C)** A single array that can hold twice as many elements as a normal array
- **D)** A synonym for an \(ArrayList\)

Which line of code correctly declares and creates a 2D \(int\) array with 3 rows and 4 columns?

- **A)** \(int[][]\ grid\ =\ new\ int[4][3];\) (dimensions reversed)
- **B)** \(int[3][4]\ grid;\)
- **C)** \(int[]\ grid\ =\ new\ int[3,\ 4];\)
- **D)** \(int[][]\ grid\ =\ new\ int[3][4];\)

Given \(int[][]\ grid\ =\ new\ int[3][4];\), how is a SPECIFIC element accessed, such as the element in row 1, column 2?

- **A)** \(grid[2][1]\) (row and column swapped)
- **B)** \(grid[1,\ 2]\)
- **C)** \(grid(1)(2)\)
- **D)** \(grid[1][2]\)

What does \(grid.length\) return for a 2D array declared as \(int[][]\ grid\ =\ new\ int[3][4];\)?

- **A)** \(7\), the sum of rows and columns
- **B)** \(4\), the number of columns
- **C)** \(12\), the total number of elements
- **D)** \(3\), the NUMBER OF ROWS (the length of the OUTER array)

What does \(grid[0].length\) return for \(int[][]\ grid\ =\ new\ int[3][4];\)?

- **A)** \(3\), the number of rows
- **B)** \(4\), the NUMBER OF COLUMNS (the length of ROW 0, which is itself a 1D array)
- **C)** \(12\), the total number of elements
- **D)** \(0\)

What is the standard NESTED \(for\) loop pattern for visiting EVERY element of a 2D array \(grid\) with \(R\) rows and \(C\) columns?

- **A)** \(for\ (int\ row\ =\ grid.length;\ row\ \textgreater\ 0;\ row++)\ \{\ ...\ \}\)
- **B)** \(for\ (int\ col\ =\ 0;\ col\ \textless\ grid.length;\ col++)\ \{\ for\ (int\ row\ =\ 0;\ row\ \textless\ grid[col].length;\ row++)\ \{\ ...\ \}\ \}\) (row/col loop variables swapped incorrectly)
- **C)** \(for\ (int\ row\ =\ 0;\ row\ \textless\ grid.length;\ row++)\ \{\ for\ (int\ col\ =\ 0;\ col\ \textless\ grid[row].length;\ col++)\ \{\ ...\ grid[row][col]\ ...\ \}\ \}\)
- **D)** \(for\ (int\ row\ =\ 0;\ row\ \textless\ grid.length;\ row++)\ \{\ ...\ grid[row]\ ...\ \}\) (single loop, no inner loop)

What is ROW-MAJOR ORDER, as it applies to traversing a 2D array?

- **A)** Row-major order only applies to 1D arrays, never 2D arrays
- **B)** Visiting elements in a completely random order
- **C)** Visiting all elements of ROW 0 first (left to right), THEN all elements of row 1, then row 2, and so on -- the order naturally produced by the standard nested loop with rows as the OUTER loop
- **D)** Visiting all elements of COLUMN 0 first, then column 1, and so on

To traverse a 2D array in COLUMN-MAJOR order (visiting all of column 0 first, then column 1, etc.) instead of the default row-major order, what change is needed to the standard nested loop?

- **A)** No change is needed; the standard nested loop already produces column-major order by default
- **B)** Column-major order is impossible to achieve with nested loops
- **C)** SWAP which variable is the OUTER loop and which is the INNER loop -- make the COLUMN index the outer loop and the ROW index the inner loop
- **D)** Simply reverse the direction of the outer loop, keeping row as the outer variable