Arrays – FRQ Practice (AP Computer Science A)

Write a method countAbove(int[] arr, int limit) that returns how many elements in arr are strictly greater than limit.

arr = [30, 35, 28, 40], limit = 30 → output = 2

• Loop through all elements
• Use a counter
• Compare each value with the limit

public int countAbove(int[] arr, int limit) {
    int count = 0;
    for (int v : arr) {
        if (v > limit) {
            count++;
        }
    }
    return count;
}
    

Write firstEven(int[] nums) that returns the index of the first even number. If none exist, return -1.

[3, 5, 8, 9] → returns 2

• Loop from the start
• Check if each element is even
• Return index immediately

public int firstEven(int[] nums) {
    for (int i = 0; i < nums.length; i++) {
        if (nums[i] % 2 == 0) {
            return i;
        }
    }
    return -1;
}
    

Return the largest value in the array.

[4, 9, 2] → 9

• Assume the first element is the maximum
• Compare it with remaining elements

public int findMax(int[] nums) {
    int max = nums[0];
    for (int i = 1; i < nums.length; i++) {
        if (nums[i] > max) {
            max = nums[i];
        }
    }
    return max;
}
    

Return the sum of all elements in the array.

[2, 4, 6] → 12

• Initialize a sum variable
• Add each element

public int sumArray(int[] nums) {
    int sum = 0;
    for (int n : nums) {
        sum += n;
    }
    return sum;
}
    

Return how many even numbers are present in the array.

[1, 2, 4, 7] → 2

• Check n % 2 == 0
• Maintain a counter

public int countEven(int[] nums) {
    int count = 0;
    for (int n : nums) {
        if (n % 2 == 0) {
            count++;
        }
    }
    return count;
}
    

Given an array, return a new array where each element is the sum of all previous elements including itself.

[2, 3, 5] → [2, 5, 10]

• Use a running sum variable
• Build a new array for output

public int[] runningTotal(int[] values) {
    int[] result = new int[values.length];
    int sum = 0;

    for (int i = 0; i < values.length; i++) {
        sum += values[i];
        result[i] = sum;
    }
    return result;
}
    

Write fixNegatives(int[] arr) to replace every negative value with 0. Modify the array directly.

public void fixNegatives(int[] arr) {
    for (int i = 0; i < arr.length; i++) {
        if (arr[i] < 0) {
            arr[i] = 0;
        }
    }
}
    

Return the average of all values as a double.

[2, 4, 6] → 4.0

• Compute the sum
• Divide using type casting

public double average(int[] nums) {
    int sum = 0;
    for (int n : nums) {
        sum += n;
    }
    return (double) sum / nums.length;
}
    

Return how many values fall within [low, high] inclusive.

[3, 7, 10], low = 5, high = 10 → 2

• Check both lower and upper bounds
• Count qualifying values

public int countInRange(int[] nums, int low, int high) {
    int count = 0;
    for (int n : nums) {
        if (n >= low && n <= high) {
            count++;
        }
    }
    return count;
}
    

Return the length of the longest consecutive streak of equal values.

[2, 2, 3, 3, 3] → 3

• Track current streak
• Update maximum when values repeat

public int longestStreak(int[] nums) {
    int max = 1;
    int curr = 1;

    for (int i = 1; i < nums.length; i++) {
        if (nums[i] == nums[i - 1]) {
            curr++;
            max = Math.max(max, curr);
        } else {
            curr = 1;
        }
    }
    return max;
}
    

Shift all elements one position to the left, moving the first element to the end.

[1, 2, 3] → [2, 3, 1]

• Store the first element
• Shift remaining elements
• Place stored value at the end

public void shiftLeft(int[] nums) {
    int first = nums[0];
    for (int i = 0; i < nums.length - 1; i++) {
        nums[i] = nums[i + 1];
    }
    nums[nums.length - 1] = first;
}
    

Return true if the array reads the same forward and backward.

[1, 2, 2, 1] → true

• Compare symmetric elements

public boolean isPalindrome(int[] nums) {
    for (int i = 0; i < nums.length / 2; i++) {
        if (nums[i] != nums[nums.length - 1 - i]) {
            return false;
        }
    }
    return true;
}
    

Return how many unique values exist in a sorted array.

[1, 1, 2, 3, 3] → 3

• Compare each value with the previous one

public int countUnique(int[] nums) {
    int count = 1;
    for (int i = 1; i < nums.length; i++) {
        if (nums[i] != nums[i - 1]) {
            count++;
        }
    }
    return count;
}
    

Return the index of the first occurrence of a target value, or -1 if not found.

[4, 6, 8], target = 6 → 1

• Use linear search
• Return immediately when found

public int findFirst(int[] nums, int target) {
    for (int i = 0; i < nums.length; i++) {
        if (nums[i] == target) {
            return i;
        }
    }
    return -1;
}
    

Return the length of the longest strictly increasing consecutive streak.

[3, 4, 5, 2, 3, 4, 6] → 4

• Track current and longest streaks
• Reset when order breaks

public int longestIncreasingStreak(int[] arr) {
    int longest = 1;
    int current = 1;

    for (int i = 1; i < arr.length; i++) {
        if (arr[i] > arr[i - 1]) {
            current++;
        } else {
            longest = Math.max(longest, current);
            current = 1;
        }
    }
    return Math.max(longest, current);
}