2D Array Neighbors and Diagonals in AP CSA: Complete Guide (2025-2026)

Working with 2D array neighbors is one of the most challenging Unit 4 topics and a consistent FRQ target. Tasks include counting orthogonal neighbors, checking diagonals, processing borders, and building neighbor-based computations. The critical skill: writing correct bounds checks that prevent ArrayIndexOutOfBoundsException on edge and corner cells.

2D Array Indexing Recap

• grid[r][c] — row r, column c
• Valid rows: 0 to grid.length - 1
• Valid columns: 0 to grid[0].length - 1
• Row 0 is top; larger row = further down

Neighbor Directions and Bounds

• Up: grid[r-1][c] — requires r > 0
• Down: grid[r+1][c] — requires r < grid.length - 1
• Left: grid[r][c-1] — requires c > 0
• Right: grid[r][c+1] — requires c < grid[r].length - 1

Code Examples

Example 1: Count Orthogonal Neighbors Equal to a Value

public class GridCount {
    public static int countAdjacent(int[][] grid, int r, int c, int val) {
        int count = 0;
        if (r > 0               && grid[r-1][c] == val) {
            count++; // up
        }
        if (r < grid.length-1   && grid[r+1][c] == val) {
            count++; // down
        }
        if (c > 0               && grid[r][c-1] == val) {
            count++; // left
        }
        if (c < grid[r].length-1 && grid[r][c+1] == val) {
            count++; // right
        }
        return count;
    }
    public static void main(String[] args) {
        int[][] grid = {{0,1,0},{1,0,1},{0,1,0}};
        System.out.println(countAdjacent(grid, 1, 1, 1)); // interior
        System.out.println(countAdjacent(grid, 0, 0, 1)); // corner
    }
}

Example 2: All 8 Neighbors via Offset Arrays

public class GridAll8 {
    static int[] DR = {-1,-1,-1,0,0,1,1,1};
    static int[] DC = {-1,0,1,-1,1,-1,0,1};

    public static int countPositive(int[][] g, int r, int c) {
        int cnt = 0;
        for (int d = 0; d < DR.length; d++) {
            int nr = r + DR[d], nc = c + DC[d];
            if (nr >= 0 && nr < g.length && nc >= 0 && nc < g[0].length)
                if (g[nr][nc] > 0) {
                    cnt++;
                }
        }
        return cnt;
    }
    public static void main(String[] args) {
        int[][] g = {{2,0,3},{1,4,0},{0,5,1}};
        System.out.println(countPositive(g, 1, 1));
    }
}

Example 3: Counting Border Cells

public class BorderCells {
    public static int countBorder(int[][] grid) {
        int count = 0;
        for (int r = 0; r < grid.length; r++)
            for (int c = 0; c < grid[r].length; c++)
                if (r==0 || c==0 || r==grid.length-1 || c==grid[r].length-1)
                    count++;
        return count;
    }
    public static void main(String[] args) {
        System.out.println("3x3: " + countBorder(new int[3][3]));
        System.out.println("4x5: " + countBorder(new int[4][5]));
    }
}

Common Pitfalls

Check for Understanding

if (r > 0 && c > 0 && r < grid.length - 1) {{ ... }}

if (r > 0 && grid[r-1][c]==1) {
    count++;      // up
}
if (r < grid.length && grid[r+1][c]==1) {
    count++;  // L2: down
}
if (c > 0 && grid[r][c-1]==1) {
    count++;      // left
}
if (c < grid[0].length && grid[r][c+1]==1) {
    count++; // L4: right
}

public static int diagSum(int[][] g) {{
    int total = 0;
    for (int r = 0; r < g.length - 1; r++)
        for (int c = 0; c < g[r].length - 1; c++)
            total += g[r+1][c+1];
    return total;
}}

Frequently Asked Questions

Related Topics