1class Solution {
2    // Static map to store the English spelling of single digit numbers (0-9)
3    private static final Map<Integer, String> digitToWord = new HashMap<>();
4    static {
5        digitToWord.put(0, "zero");
6        digitToWord.put(1, "one");
7        digitToWord.put(2, "two");
8        digitToWord.put(3, "three");
9        digitToWord.put(4, "four");
10        digitToWord.put(5, "five");
11        digitToWord.put(6, "six");
12        digitToWord.put(7, "seven");
13        digitToWord.put(8, "eight");
14        digitToWord.put(9, "nine");
15    }
16
17    /**
18     * Returns the count of distinct letters that appear an odd number of times
19     * in the English words for the digits of n.
20     *
21     * @param n The input number
22     * @return The number of letters with odd frequency
23     */
24    public int countOddLetters(int n) {
25        // Bitmask to track parity of each letter (a-z) using bit manipulation
26        int mask = 0;
27        while (n > 0) {
28            int digit = n % 10;
29            n /= 10;
30            // Get the English word for this digit
31            String word = digitToWord.get(digit);
32            // Flip the corresponding bit for each letter
33            for (char ch : word.toCharArray()) {
34                mask ^= 1 << (ch - 'a');
35            }
36        }
37        // The number of bits set represents the number of letters that appeared odd times
38        return Integer.bitCount(mask);
39    }
40}
41

1#include <unordered_map>
2#include <string>
3
4class Solution {
5public:
6    int countOddLetters(int n) {
7        // Map digits to their English word representations
8        static const std::unordered_map<int, std::string> digitToWord = {
9            {0, "zero"},
10            {1, "one"},
11            {2, "two"},
12            {3, "three"},
13            {4, "four"},
14            {5, "five"},
15            {6, "six"},
16            {7, "seven"},
17            {8, "eight"},
18            {9, "nine"}
19        };
20
21        int letterMask = 0; // Bitmask to track odd/even counts of each letter
22
23        // Process each digit of the number
24        while (n > 0) {
25            int digit = n % 10;          // Get the last digit
26            n /= 10;                     // Remove the last digit
27
28            // For each character in the word for this digit
29            for (char ch : digitToWord.at(digit)) {
30                // Use XOR to toggle the bit representing this letter
31                letterMask ^= 1 << (ch - 'a');
32            }
33        }
34
35        // Count the number of set bits (letters with odd occurrences)
36        return __builtin_popcount(letterMask);
37    }
38};
39

1// Mapping from digit to its English word representation
2const digitToWord: Record<number, string> = {
3    0: 'zero',
4    1: 'one',
5    2: 'two',
6    3: 'three',
7    4: 'four',
8    5: 'five',
9    6: 'six',
10    7: 'seven',
11    8: 'eight',
12    9: 'nine',
13};
14
15/**
16 * For a given number n, convert each digit to its English word,
17 * and for all letters, count the number of letters that occur an odd number of times.
18 * Uses bitmasking to efficiently track letter parity.
19 */
20function countOddLetters(n: number): number {
21    let mask = 0;
22    while (n > 0) {
23        const digit = n % 10;
24        n = Math.floor(n / 10);
25
26        // For each letter in the word for this digit, toggle its bit
27        for (const ch of digitToWord[digit]) {
28            const bit = ch.charCodeAt(0) - 'a'.charCodeAt(0);
29            mask ^= 1 << bit;
30        }
31    }
32
33    // Count number of bits set in mask (number of odd-occurrence letters)
34    return bitCount(mask);
35}
36
37/**
38 * Counts the number of set bits (1s) in the binary representation of i.
39 * Uses parallel bit counting technique (Hamming Weight).
40 */
41function bitCount(i: number): number {
42    i = i - ((i >>> 1) & 0x55555555);                // Subtract each pair of bits
43    i = (i & 0x33333333) + ((i >>> 2) & 0x33333333); // Sum bits in each nibble
44    i = (i + (i >>> 4)) & 0x0f0f0f0f;                // Sum bits in each byte
45    i = i + (i >>> 8);                               // Aggregate higher
46    i = i + (i >>> 16);                              // Aggregate final result
47    return i & 0x3f;                                 // Only the lowest 6 bits are needed (26 letters)
48}
49