1class Solution {
2    /**
3     * Reverses every word whose vowel count matches the vowel count of the first word.
4     *
5     * @param s the input sentence (words separated by whitespace)
6     * @return the resulting sentence after conditional reversal
7     */
8    public String reverseWords(String s) {
9        // Split the input on one or more whitespace characters.
10        String[] words = s.split("\\s+");
11
12        // Use the first word's vowel count as the reference value.
13        int referenceVowelCount = calc(words[0]);
14
15        // Collect the processed words here.
16        List<String> result = new ArrayList<>();
17
18        // The first word is always added as-is (it is its own reference).
19        result.add(words[0]);
20
21        // Process the remaining words one by one.
22        for (int i = 1; i < words.length; i++) {
23            String word = words[i];
24
25            // If this word has the same number of vowels as the reference,
26            // reverse it; otherwise keep it unchanged.
27            if (calc(word) == referenceVowelCount) {
28                result.add(new StringBuilder(word).reverse().toString());
29            } else {
30                result.add(word);
31            }
32        }
33
34        // Re-join the words into a single space-separated sentence.
35        return String.join(" ", result);
36    }
37
38    /**
39     * Counts the number of lowercase vowels (a, e, i, o, u) in the given word.
40     *
41     * @param word the word to inspect
42     * @return the number of vowels found
43     */
44    private int calc(String word) {
45        int count = 0;
46        for (char c : word.toCharArray()) {
47            // Increment the counter whenever the character is a vowel.
48            if (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u') {
49                count++;
50            }
51        }
52        return count;
53    }
54}
55

1class Solution {
2public:
3    string reverseWords(string s) {
4        // Use a stream to split the input into words by whitespace.
5        stringstream ss(s);
6        string word;
7
8        // Read the first word; its vowel count is the reference value.
9        ss >> word;
10        int referenceVowelCount = countVowels(word);
11
12        // The first word is appended as-is (it defines the reference count).
13        string ans = word;
14
15        // Process every remaining word.
16        while (ss >> word) {
17            // Separate words with a single space.
18            ans.push_back(' ');
19
20            // If this word has the same number of vowels as the first word,
21            // reverse its characters before appending.
22            if (countVowels(word) == referenceVowelCount) {
23                reverse(word.begin(), word.end());
24            }
25
26            ans += word;
27        }
28
29        return ans;
30    }
31
32private:
33    // Count the number of vowels (a, e, i, o, u) in the given word.
34    int countVowels(const string& word) {
35        return count_if(word.begin(), word.end(), [](char c) {
36            return c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u';
37        });
38    }
39};
40

1function reverseWords(s: string): string {
2    // Split the input string into words, using one or more whitespace characters as the delimiter
3    const words: string[] = s.split(/\s+/);
4
5    // Helper function: count the number of vowels (a, e, i, o, u) in a given word
6    const countVowels = (word: string): number => {
7        let count = 0;
8        for (const ch of word) {
9            if ('aeiou'.includes(ch)) {
10                count++;
11            }
12        }
13        return count;
14    };
15
16    // Use the vowel count of the first word as the reference value
17    const referenceCount: number = countVowels(words[0]);
18
19    // The result array starts with the first word unchanged
20    const result: string[] = [words[0]];
21
22    // Iterate over the remaining words starting from the second one
23    for (let i = 1; i < words.length; i++) {
24        let word: string = words[i];
25
26        // If the current word has the same vowel count as the reference, reverse it
27        if (countVowels(word) === referenceCount) {
28            word = word.split('').reverse().join('');
29        }
30
31        // Append the (possibly reversed) word to the result
32        result.push(word);
33    }
34
35    // Join all words back into a single string separated by spaces
36    return result.join(' ');
37}
38