1class Solution {
2    /**
3     * For each word, compute the sum of its characters' weights modulo 26,
4     * then map that value to a character using the formula 'a' + (25 - sum).
5     *
6     * @param words   the array of input words (assumed to contain only lowercase letters)
7     * @param weights an array of length 26 where weights[i] is the weight of ('a' + i)
8     * @return a string whose i-th character is derived from the i-th word
9     */
10    public String mapWordWeights(String[] words, int[] weights) {
11        // Accumulates the resulting characters for each word.
12        StringBuilder ans = new StringBuilder();
13
14        // Process every word independently.
15        for (String word : words) {
16            // Running sum of weights, kept within [0, 25] via modulo 26.
17            int sum = 0;
18            for (char ch : word.toCharArray()) {
19                sum = (sum + weights[ch - 'a']) % 26;
20            }
21
22            // Map the computed sum to a character: index 0 -> 'z', 25 -> 'a'.
23            ans.append((char) ('a' + (25 - sum)));
24        }
25
26        return ans.toString();
27    }
28}
29

1class Solution {
2public:
3    // Maps each word to a single character based on the weighted sum of its letters.
4    string mapWordWeights(vector<string>& words, vector<int>& weights) {
5        string result;
6        result.reserve(words.size());
7
8        for (const string& word : words) {
9            int weightedSum = 0;
10
11            // Accumulate the weight of every character, keeping the value within [0, 25].
12            for (char ch : word) {
13                weightedSum = (weightedSum + weights[ch - 'a']) % 26;
14            }
15
16            // Convert the complement of the sum (25 - sum) into a lowercase letter.
17            result.push_back(static_cast<char>('a' + (25 - weightedSum)));
18        }
19
20        return result;
21    }
22};
23

1/**
2 * Maps each word to a single character based on the cumulative weight of its letters.
3 *
4 * For every word, the weights of its characters (looked up by their position in the
5 * alphabet) are summed modulo 26. The resulting value `s` is then transformed into a
6 * letter using `25 - s`, producing one output character per input word. All these
7 * characters are concatenated to form the final result string.
8 *
9 * @param words   - The list of input words to process.
10 * @param weights - A length-26 array mapping each letter ('a'..'z') to a numeric weight.
11 * @returns A string composed of one character per input word.
12 */
13function mapWordWeights(words: string[], weights: number[]): string {
14    // Collects the single character computed for each word.
15    const result: string[] = [];
16
17    for (const word of words) {
18        // Accumulated weight for the current word, kept within [0, 25].
19        let sum = 0;
20
21        for (const char of word) {
22            // Convert the character to its alphabet index (0 for 'a', 25 for 'z'),
23            // add its weight, and wrap around using modulo 26.
24            sum = (sum + weights[char.charCodeAt(0) - 97]) % 26;
25        }
26
27        // Mirror the value within the alphabet (25 - sum) and convert back to a letter.
28        result.push(String.fromCharCode(97 + (25 - sum)));
29    }
30
31    // Join all per-word characters into the final string.
32    return result.join('');
33}
34