Strings – FRQ Practice (AP Computer Science A)

Write countVowels(String s) that returns how many vowels (a, e, i, o, u) appear in the string. Ignore case.

“Computer” → 3

• Convert the string to lowercase
• Traverse each character
• Check membership in "aeiou"

public int countVowels(String s) {
    int count = 0;
    String low = s.toLowerCase();

    for (int i = 0; i < low.length(); i++) {
        if ("aeiou".indexOf(low.charAt(i)) != -1) {
            count++;
        }
    }
    return count;
}
    

Write removeDigits(String s) that returns a new string with all digits removed.

"a1b2c3d4" → "abcd"

• Traverse the string
• Append only non-digit characters
• Use Character.isDigit()

public String removeDigits(String s) {
    StringBuilder result = new StringBuilder();

    for (int i = 0; i < s.length(); i++) {
        if (!Character.isDigit(s.charAt(i))) {
            result.append(s.charAt(i));
        }
    }
    return result.toString();
}
    

Write reverseString(String s) that returns the reversed string.

"java" → "avaj"

• Traverse from the last index to 0
• Append characters to a new string

public String reverseString(String s) {
    StringBuilder rev = new StringBuilder();

    for (int i = s.length() - 1; i >= 0; i--) {
        rev.append(s.charAt(i));
    }
    return rev.toString();
}
    

Assume words are separated by a single space. Return the number of words in the string.

"AP Computer Science" → 3

• Count spaces
• Words = spaces + 1

public int countWords(String s) {
    if (s.length() == 0) return 0;

    int count = 1;
    for (int i = 0; i < s.length(); i++) {
        if (s.charAt(i) == ' ') {
            count++;
        }
    }
    return count;
}
    

Write longestWord(String sentence) that returns the longest word. Assume words are separated by spaces.

"I love programming in Java" → "programming"

• Split the sentence using spaces
• Track the longest word

public String longestWord(String sentence) {
    String[] words = sentence.split(" ");
    String longest = "";

    for (String w : words) {
        if (w.length() > longest.length()) {
            longest = w;
        }
    }
    return longest;
}
    

Write removeVowels(String s) that removes all vowels (case-insensitive) from the string.

"Computer" → "Cmptr"

• Traverse each character
• Convert to lowercase for checking
• Append only non-vowel characters

public String removeVowels(String s) {
    StringBuilder result = new StringBuilder();

    for (int i = 0; i < s.length(); i++) {
        char c = Character.toLowerCase(s.charAt(i));
        if ("aeiou".indexOf(c) == -1) {
            result.append(s.charAt(i));
        }
    }
    return result.toString();
}
    

Write isPalindrome(String s) that returns true if the string reads the same forwards and backwards.

"level" → true

• Use two pointers from start and end
• Compare characters
• Stop early if mismatch occurs

public boolean isPalindrome(String s) {
    int left = 0;
    int right = s.length() - 1;

    while (left < right) {
        if (s.charAt(left) != s.charAt(right)) {
            return false;
        }
        left++;
        right--;
    }
    return true;
}
    

Write countUppercase(String s) that returns the number of uppercase letters in the string.

"ApCSa" → 2

• Traverse the string
• Use Character.isUpperCase()

public int countUppercase(String s) {
    int count = 0;

    for (int i = 0; i < s.length(); i++) {
        if (Character.isUpperCase(s.charAt(i))) {
            count++;
        }
    }
    return count;
}
    

Write countOccurrences(String s, String sub) that counts overlapping occurrences of sub.

"aaaa", "aa" → 3

• Slide a window of length sub.length()
• Move one index at a time
• Compare substrings

public int countOccurrences(String s, String sub) {
    int count = 0;

    for (int i = 0; i <= s.length() - sub.length(); i++) {
        if (s.substring(i, i + sub.length()).equals(sub)) {
            count++;
        }
    }
    return count;
}
    

A valid ID has 2 letters followed by 4 digits. Return true if the format is valid.

"AB1234" → true

• Check string length
• Validate letters and digits separately

public boolean isValidID(String id) {
    if (id.length() != 6) return false;

    if (!Character.isLetter(id.charAt(0)) ||
        !Character.isLetter(id.charAt(1))) {
        return false;
    }

    for (int i = 2; i < 6; i++) {
        if (!Character.isDigit(id.charAt(i))) {
            return false;
        }
    }
    return true;
}
    

Replace multiple consecutive spaces with a single space.

"AP Computer Science" → "AP Computer Science"

• Traverse characters one by one
• Append character if previous is not a space

public String removeExtraSpaces(String s) {
    StringBuilder result = new StringBuilder();

    for (int i = 0; i < s.length(); i++) {
        if (i == 0 || s.charAt(i) != ' ' || s.charAt(i - 1) != ' ') {
            result.append(s.charAt(i));
        }
    }
    return result.toString();
}
    

Return a string containing only digits from the input string.

"ab12cd34" → "1234"

• Traverse each character
• Append digits only

public String extractDigits(String s) {
    StringBuilder result = new StringBuilder();

    for (int i = 0; i < s.length(); i++) {
        if (Character.isDigit(s.charAt(i))) {
            result.append(s.charAt(i));
        }
    }
    return result.toString();
}
    

Return the character with the longest consecutive repetition. Assume the string is non-empty.

"aaabbccccd" → 'c'

• Track current streak length
• Track longest streak and character

public char longestStreak(String s) {
    char best = s.charAt(0);
    int bestCount = 1;
    int count = 1;

    for (int i = 1; i < s.length(); i++) {
        if (s.charAt(i) == s.charAt(i - 1)) {
            count++;
            if (count > bestCount) {
                bestCount = count;
                best = s.charAt(i);
            }
        } else {
            count = 1;
        }
    }
    return best;
}
    

Compress consecutive characters using counts.

"aaabbc" → "a3b2c1"

• Count consecutive characters
• Append character followed by count

public String compress(String s) {
    StringBuilder result = new StringBuilder();
    int count = 1;

    for (int i = 1; i <= s.length(); i++) {
        if (i < s.length() && s.charAt(i) == s.charAt(i - 1)) {
            count++;
        } else {
            result.append(s.charAt(i - 1)).append(count);
            count = 1;
        }
    }
    return result.toString();
}
    

Mask all characters of the email username except the first and last character.

"john.doe@gmail.com" → "j*****e@gmail.com"

• Separate username and domain
• Replace middle characters with '*'

public String maskEmail(String email) {
    int at = email.indexOf('@');
    String user = email.substring(0, at);
    String domain = email.substring(at);

    if (user.length() <= 2) return email;

    StringBuilder masked = new StringBuilder();
    masked.append(user.charAt(0));

    for (int i = 1; i < user.length() - 1; i++) {
        masked.append('*');
    }

    masked.append(user.charAt(user.length() - 1));
    return masked.toString() + domain;
}