FRQ Practice

Strategy: Build the answer one character at a time. For each character, check if it's in the key — if yes, append *; if not, append the character itself.

public static String hide(String message, String key) {
    String result = "";
    for (int i = 0; i < message.length(); i++) {
        String ch = message.substring(i, i + 1);
        if (key.indexOf(ch) >= 0) {
            result += "*";
        } else {
            result += ch;
        }
    }
    return result;
}

Why this scores 9/9: Walks every char, uses indexOf for key check (returns –1 when not found), builds result correctly, handles edge cases (empty key works too).

public static int digitSum(int n) {
    if (n == 0) return 0;
    int sum = 0;
    while (n > 0) {
        sum += n % 10;
        n = n / 10;
    }
    return sum;
}

public static boolean isDigitMultiple(int n) {
    int s = digitSum(n);
    if (s == 0) return n == 0;   // avoid divide by zero
    return n % s == 0;
}

class Locker {
    private int number;
    private String owner;

    public Locker(int number) {
        this.number = number;
        owner = "";
    }

    public int getNumber()    { return number; }
    public String getOwner()  { return owner;  }
    public boolean isAvailable() { return owner.equals(""); }

    public boolean assign(String name) {
        if (!isAvailable()) return false;
        owner = name;
        return true;
    }

    public void release() { owner = ""; }
}

Common mistakes: Using == instead of .equals() for the empty String check, forgetting private on instance variables, having assign always update (even when the locker is taken).

public static int countPassing(ArrayList<Integer> scores, int min) {
    int count = 0;
    for (int s : scores) {
        if (s >= min) count++;
    }
    return count;
}

public static void removeFailing(ArrayList<Integer> scores, int min) {
    // Iterate BACKWARDS to avoid index-shifting bugs
    for (int i = scores.size() - 1; i >= 0; i--) {
        if (scores.get(i) < min) scores.remove(i);
    }
}

Common bug: Iterating forward with remove. After you remove index i, the next element shifts into i — but your loop increments to i+1, skipping it. Iterate backwards.

public static int countEmpty(String[][] room) {
    int count = 0;
    for (int r = 0; r < room.length; r++) {
        for (int c = 0; c < room[r].length; c++) {
            if (room[r][c].equals("")) count++;
        }
    }
    return count;
}

public static int rowWithMostStudents(String[][] room) {
    int bestRow = 0, bestCount = -1;
    for (int r = 0; r < room.length; r++) {
        int count = 0;
        for (int c = 0; c < room[r].length; c++) {
            if (!room[r][c].equals("")) count++;
        }
        if (count > bestCount) {     // strictly greater → ties go to smaller index
            bestCount = count;
            bestRow   = r;
        }
    }
    return bestRow;
}

public static void compactRow(String[][] room, int r) {
    int writeIdx = 0;
    String[] row = room[r];
    // Pass 1: collect non-empties at the start
    for (int c = 0; c < row.length; c++) {
        if (!row[c].equals("")) {
            row[writeIdx++] = row[c];
        }
    }
    // Pass 2: fill the rest with ""
    while (writeIdx < row.length) row[writeIdx++] = "";
}

The two-pointer trick: A write index tracks where to put the next non-empty. After scanning, fill the tail with empties. This is the standard "compact" pattern.