java · level 3 check

a concurrent word counter.

Time to ship a real tool: a word counter. The first line typed says how many top words to show, from 1 to 20. Every line after it is text. The tool counts each line as its own job on a thread pool, then prints a sorted report.

Make it robust. The two patterns in `wordsIn` keep only letters and apostrophes, then trim stray quote marks, so `Cat,` and `cat` count together and `don't` stays whole. A bad first line, like `lots`, gets a clear error instead of a crash, and text with no words says so.

Lines finish in any order, so their counts merge into one `ConcurrentHashMap`, and the report sorts by count, highest first, then alphabetically. That keeps the output identical on every run. Fill in each `____`, then try it on your own text.

Your program

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Scanner;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.stream.Collectors;
public class Main {
    static final int MAX_TOP = 20;

static class WordCount {
        private final String word;
        private final int count;
        WordCount(String word, int count) {
            this.word = word;
            this.count = count;
        }
        String getWord() { return word; }
        int getCount() { return count; }
    }

static Optional<Integer> parseTop(String line) {
        try {
            return Optional.of(Integer.parseInt(line.trim())).filter(____);
        } catch (NumberFormatException e) {
            return Optional.empty();
        }
    }

static List<String> wordsIn(String line) {
        return Arrays.stream(line.toLowerCase().split("[^a-z']+"))
            .map(word -> word.replaceAll("^'+|'+$", ""))
            .filter(____)
            .collect(Collectors.toList());
    }

static Map<String, Integer> countWords(List<String> lines) throws Exception {
        Map<String, Integer> counts = new ConcurrentHashMap<>();
        ExecutorService pool = Executors.newFixedThreadPool(4);
        List<Future<?>> jobs = new ArrayList<>();
        for (String line : lines) {
            jobs.add(pool.submit(() -> wordsIn(line).forEach(word -> counts.merge(word, 1, ____))));
        }
        pool.____();
        for (Future<?> job : jobs) {
            job.get();
        }
        return counts;
    }

static List<WordCount> rank(Map<String, Integer> counts) {
        return counts.entrySet().stream()
            .map(entry -> new WordCount(entry.getKey(), entry.getValue()))
            .sorted(Comparator.comparing(WordCount::getCount).____().thenComparing(____))
            .collect(Collectors.toList());
    }

public static void main(String[] args) throws Exception {
        Scanner input = new Scanner(System.in);
        String first = "";
        if (input.hasNextLine()) {
            first = input.nextLine();
        }
        Optional<Integer> top = parseTop(first);
        if (top.isEmpty()) {
            System.out.println("Error: the first line must be a whole number from 1 to " + MAX_TOP + ".");
            return;
        }
        List<String> lines = new ArrayList<>();
        while (input.hasNextLine()) {
            lines.add(input.nextLine());
        }
        List<WordCount> ranking = rank(countWords(lines));
        if (ranking.isEmpty()) {
            System.out.println("No words found.");
            return;
        }
        int total = ranking.stream().mapToInt(WordCount::getCount).sum();
        int shown = Math.min(top.orElseThrow(), ranking.size());
        System.out.println("Words: " + total + ", unique: " + ranking.size());
        System.out.println("Top " + shown + ":");
        for (int i = 0; i < shown; i++) {
            WordCount entry = ranking.get(i);
            System.out.println((i + 1) + ". " + entry.getWord() + " (" + entry.getCount() + ")");
        }
    }
}

Fill in every ____ then run the checks.

1 It counts every word on every lineuses: streams
2 It ranks by count, then alphabeticallyuses: comparators
3 It ignores capitals and punctuationuses: text
4 It keeps words like don't wholeuses: text
5 It refuses a bad first lineuses: Optional
6 It copes with text that has no wordsuses: edge cases

Take as long as you like and try as many times as you want.

a concurrent word counter.

level up.

playground