1class Solution {
2    /**
3     * Counts the occurrences of each queried word within the text formed
4     * by concatenating all the given chunks.
5     *
6     * Word boundaries are defined by spaces. A hyphen '-' is treated as part
7     * of a word only when it sits between two non-space, non-hyphen characters
8     * (i.e. a true intra-word hyphen). Otherwise it acts as a separator.
9     *
10     * @param chunks  the pieces of text to be concatenated into a single string
11     * @param queries the words whose occurrences need to be counted
12     * @return an array where each element is the count of the corresponding query word
13     */
14    public int[] countWordOccurrences(String[] chunks, String[] queries) {
15        // Concatenate all chunks into one continuous string.
16        StringBuilder builder = new StringBuilder();
17        for (String chunk : chunks) {
18            builder.append(chunk);
19        }
20        String text = builder.toString();
21        int length = text.length();
22
23        // Map to store how many times each extracted word appears.
24        Map<String, Integer> wordCount = new HashMap<>();
25
26        int index = 0;
27        while (index < length) {
28            char current = text.charAt(index);
29
30            // Skip leading separators (spaces or hyphens that start a token).
31            if (current == ' ' || current == '-') {
32                index++;
33                continue;
34            }
35
36            // Scan forward to find the end of the current word.
37            int end = index;
38            while (end < length) {
39                char ch = text.charAt(end);
40
41                // A space always ends the current word.
42                if (ch == ' ') {
43                    break;
44                }
45
46                // A hyphen ends the word unless it is a genuine intra-word hyphen,
47                // meaning the next character is also a normal word character.
48                if (ch == '-') {
49                    if (end + 1 < length) {
50                        char next = text.charAt(end + 1);
51                        if (next == ' ' || next == '-') {
52                            break;
53                        }
54                    } else {
55                        // Trailing hyphen at the very end: treat as separator.
56                        break;
57                    }
58                }
59
60                end++;
61            }
62
63            // Extract the word and update its count.
64            String word = text.substring(index, end);
65            wordCount.put(word, wordCount.getOrDefault(word, 0) + 1);
66
67            // Move to the position right after the current word.
68            index = end;
69        }
70
71        // Build the answer array based on the query words.
72        int[] answer = new int[queries.length];
73        for (int k = 0; k < queries.length; k++) {
74            answer[k] = wordCount.getOrDefault(queries[k], 0);
75        }
76        return answer;
77    }
78}
79

1class Solution {
2public:
3    vector<int> countWordOccurrences(vector<string>& chunks, vector<string>& queries) {
4        // Concatenate all chunks into a single string for unified processing.
5        string text;
6        for (const string& chunk : chunks) {
7            text += chunk;
8        }
9
10        int length = static_cast<int>(text.length());
11
12        // Map each distinct word to the number of times it appears.
13        unordered_map<string, int> wordCount;
14
15        int start = 0;
16        while (start < length) {
17            // Skip separators (spaces and standalone hyphens).
18            if (text[start] == ' ' || text[start] == '-') {
19                start++;
20                continue;
21            }
22
23            // Advance 'end' to find the boundary of the current word.
24            // A space always ends a word. A hyphen ends the word only when it
25            // is NOT acting as an in-word connector, i.e. it is immediately
26            // followed by another separator (or the end of the string).
27            int end = start;
28            while (end < length && text[end] != ' ' &&
29                   (text[end] != '-' ||
30                    (end + 1 < length && text[end + 1] != ' ' && text[end + 1] != '-'))) {
31                end++;
32            }
33
34            // Record the extracted word [start, end).
35            wordCount[text.substr(start, end - start)]++;
36
37            // Continue scanning from where the current word ended.
38            start = end;
39        }
40
41        // Resolve each query against the precomputed counts.
42        vector<int> answer;
43        answer.reserve(queries.size());
44        for (const string& query : queries) {
45            answer.push_back(wordCount[query]);
46        }
47
48        return answer;
49    }
50};
51

1/**
2 * Counts the number of occurrences of each query word within the joined text.
3 *
4 * Words are delimited by spaces (' ') and standalone hyphens ('-').
5 * A hyphen that sits between two non-space, non-hyphen characters is treated
6 * as part of the word (e.g. "well-known" stays intact), whereas a hyphen
7 * adjacent to a space or another hyphen acts as a separator.
8 *
9 * @param chunks  - Array of string fragments that together form the full text.
10 * @param queries - Array of words whose occurrences we want to count.
11 * @returns An array where each element is the count for the corresponding query.
12 */
13function countWordOccurrences(chunks: string[], queries: string[]): number[] {
14    // Combine all fragments into a single continuous string.
15    const text: string = chunks.join('');
16    const length: number = text.length;
17
18    // Map from a word to the number of times it appears in the text.
19    const wordCount: Map<string, number> = new Map<string, number>();
20
21    let start: number = 0;
22    while (start < length) {
23        // Skip leading separators (spaces and standalone hyphens).
24        if (text[start] === ' ' || text[start] === '-') {
25            start++;
26            continue;
27        }
28
29        // Expand the window [start, end) to capture a full word.
30        let end: number = start;
31        while (
32            end < length &&
33            text[end] !== ' ' &&
34            // A hyphen is part of the word only when the next character
35            // is neither a space nor another hyphen (i.e. it is an inner hyphen).
36            (text[end] !== '-' ||
37                (end + 1 < length &&
38                    text[end + 1] !== ' ' &&
39                    text[end + 1] !== '-'))
40        ) {
41            end++;
42        }
43
44        // Extract the word and increment its tally.
45        const word: string = text.substring(start, end);
46        wordCount.set(word, (wordCount.get(word) ?? 0) + 1);
47
48        // Continue scanning from the end of the current word.
49        start = end;
50    }
51
52    // Resolve each query to its stored count, defaulting to 0 when absent.
53    return queries.map((query: string): number => wordCount.get(query) ?? 0);
54}
55