2D Array FRQ Patterns for AP CSA: How FRQ 4 Works

FRQ 4 on the AP CSA exam is always a 2D array problem. This page breaks down the recurring patterns, shows you how to earn maximum points, and gives you the step-by-step approach that works every time.

📋 FRQ 4 Structure

FRQ 4 typically has 2 parts:

1. Part (a): Process individual rows or columns (row sum, row max, count per row)
2. Part (b): Use Part (a) results across the full matrix (find which row has the highest sum, compare columns)

Part (b) almost always calls Part (a). If you get Part (a) wrong, you can still earn full credit on Part (b) by calling Part (a) correctly and using its result properly.

🔍 The 4 Core Patterns

Pattern 1: Row-Based Processing

Process each row independently, often returning an array of results.

// Return array of row sums
public int[] allRowSums()
{
    int[] sums = new int[grid.length];
    for (int r = 0; r < grid.length; r++)
    {
        for (int c = 0; c < grid[r].length; c++)
        {
            sums[r] += grid[r][c];
        }
    }
    return sums;
}

Pattern 2: Find the Row/Column Meeting a Condition

Use row processing, then scan results for the best one.

// Which row has the largest sum?
public int rowWithMaxSum()
{
    int[] sums = allRowSums();  // call Part (a)
    int maxIdx = 0;
    for (int i = 1; i < sums.length; i++)
    {
        if (sums[i] > sums[maxIdx])
        {
            maxIdx = i;
        }
    }
    return maxIdx;
}

Pattern 3: Neighbor Checking

Check elements above, below, left, right. Must guard against going out of bounds.

// Is grid[r][c] greater than all its neighbors?
public boolean isLocalMax(int r, int c)
{
    int val = grid[r][c];
    if (r > 0 && grid[r-1][c] >= val) return false;
    if (r < grid.length-1 && grid[r+1][c] >= val) return false;
    if (c > 0 && grid[r][c-1] >= val) return false;
    if (c < grid[r].length-1 && grid[r][c+1] >= val) return false;
    return true;
}

Pattern 4: Counting Elements Meeting a Condition

// Count elements in a specific row that are above average
public int countAboveAvg(int row, double avg)
{
    int count = 0;
    for (int c = 0; c < grid[row].length; c++)
    {
        if (grid[row][c] > avg)
        {
            count++;
        }
    }
    return count;
}

🛠 Step-by-Step Approach

1. Read Part (a) first. Identify what single-row or single-column operation it wants.
2. Write the inner loop. This processes one row or column.
3. Wrap in outer loop if needed. Some Part (a) methods only process one row (passed as parameter).
4. Read Part (b). It almost certainly calls Part (a). Identify what it does with the result.
5. Call Part (a) in Part (b). Do NOT copy-paste Part (a) code. Call the method.

💰 Scoring Rubric Tips

FRQ 4 rubrics consistently award points for:

1. Correct loop bounds (1-2 pts) — grid.length for rows, grid[r].length for columns
2. Accessing elements correctly (1 pt) — grid[r][c] with both indices
3. Applying the condition (1-2 pts) — the if statement inside the loop
4. Accumulating/returning the result (1 pt) — sum, count, or boolean
5. Calling Part (a) in Part (b) (1 pt) — do not rewrite the logic

✏ Practice Questions

❓ Frequently Asked Questions