Stream coding problems: interview questions & scenarios

Model answer

I would map each word to a count and collect into a LinkedHashMap if the caller needs key-value output in input order. The counting part is easiest with chars() and a predicate. In production, ask whether vowels are ASCII-only or language-aware.

import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;

public class Main {
    static long vowels(String word) {
        return word.toLowerCase(Locale.ROOT).chars()
                .filter(ch -> "aeiou".indexOf(ch) >= 0)
                .count();
    }

    public static void main(String[] args) {
        List<String> words = List.of("stream", "java", "sky");
        Map<String, Long> counts = words.stream()
                .collect(Collectors.toMap(
                        Function.identity(),
                        Main::vowels,
                        (left, right) -> left,
                        LinkedHashMap::new));
        System.out.println(counts);
    }
}

Output:

{stream=2, java=2, sky=0}

If duplicate words must appear twice, a map is the wrong result shape. Return List<WordCount> instead.

Model answer

The classifier is the sorted letters of each word after normalization. Then groupingBy collects all words with the same classifier into the same bucket. I usually use TreeMap in interview code so the printed output is deterministic.

import java.util.*;
import java.util.stream.Collectors;

public class Main {
    static String key(String word) {
        char[] chars = word.toLowerCase(Locale.ROOT).toCharArray();
        Arrays.sort(chars);
        return new String(chars);
    }

    public static void main(String[] args) {
        List<String> words = List.of("Tea", "eat", "bat", "ate", "tab");
        Map<String, List<String>> groups = words.stream()
                .collect(Collectors.groupingBy(Main::key, TreeMap::new, Collectors.toList()));
        System.out.println(groups.values());
    }
}

Output:

[[bat, tab], [Tea, eat, ate]]

Sorting each word costs O(k log k), where k is the word length. For very long strings over a small alphabet, a character-count key can be cheaper.