class Solution:
    def mapWordWeights(self, words: List[str], weights: List[int]) -> str:
        # Array to store the mapped characters for each word
        result = []

        # Iterate over each word in the input list
        for word in words:
            # Calculate the sum of weights for the characters in the current word
            word_weight = 0
            for char in word:
                # Get the weight of the character by mapping it to its index (0 for 'a', 1 for 'b', etc.)
                word_weight += weights[ord(char) - ord('a')]

            # Take the sum modulo 26 as specified in the problem
            mapped_val = word_weight % 26

            # Map the value to a character using reverse alphabetical order ('z' - value)
            mapped_char = chr(ord('z') - mapped_val)

            # Append the mapped character to the result list
            result.append(mapped_char)

        # Join the characters into a single string and return
        return "".join(result)

class Solution {
    public String mapWordWeights(String[] words, int[] weights) {
        // Use a StringBuilder for efficient string concatenation
        StringBuilder result = new StringBuilder();

        // Iterate through each word in the array
        for (String word : words) {
            int wordWeight = 0;

            // Sum the weights of all characters in the current word
            for (char c : word.toCharArray()) {
                // Determine the 0-indexed position of the character
                wordWeight += weights[c - 'a'];
            }

            // Modulo 26 operation
            int mappedVal = wordWeight % 26;

            // Calculate the mapped character using reverse alphabetical order
            // Since 'z' is the starting point (0 -> 'z'), we subtract the mapped value
            char mappedChar = (char) ('z' - mappedVal);

            // Append the mapped character to our result
            result.append(mappedChar);
        }

        // Convert the StringBuilder to String and return
        return result.toString();
    }
}

/**
 * @param {string[]} words
 * @param {number[]} weights
 * @return {string}
 */
var mapWordWeights = function(words, weights) {
    // Array to collect the resulting characters
    let result = [];

    // Process each word one by one
    for (let word of words) {
        let wordWeight = 0;

        // Sum up the weight of each character in the word
        for (let i = 0; i < word.length; i++) {
            // Find the character code difference from 'a'
            let charIndex = word.charCodeAt(i) - 97; // 97 is the ASCII for 'a'
            wordWeight += weights[charIndex];
        }

        // Apply modulo 26 to the sum
        let mappedVal = wordWeight % 26;

        // Map it back to a character starting backwards from 'z' (ASCII 122)
        let mappedChar = String.fromCharCode(122 - mappedVal);

        // Push to the result array
        result.push(mappedChar);
    }

    // Join the array into a string and return
    return result.join('');
};

class Solution {
public:
    string mapWordWeights(vector<string>& words, vector<int>& weights) {
        // String to store the concatenated mapped characters
        string result = "";

        // Process each word in the input
        for (const string& word : words) {
            int wordWeight = 0;

            // Sum the weights corresponding to each character
            for (char c : word) {
                // Find the index by subtracting the ASCII value of 'a'
                wordWeight += weights[c - 'a'];
            }

            // Perform the modulo 26 operation
            int mappedVal = wordWeight % 26;

            // Deduct the mapped value from 'z' to get the reversed mapped character
            char mappedChar = 'z' - mappedVal;

            // Append it to the result string
            result += mappedChar;
        }

        return result;
    }
};

public class Solution {
    public string mapWordWeights(string[] words, int[] weights) {
        // StringBuilder is optimal for creating strings character by character
        System.Text.StringBuilder result = new System.Text.StringBuilder();

        // Iterate over each string in words
        foreach (string word in words) {
            int wordWeight = 0;

            // Calculate total weight of the word
            foreach (char c in word) {
                // c - 'a' yields the 0-based index of the alphabet
                wordWeight += weights[c - 'a'];
            }

            // Modulo 26 ensures the value is between 0 and 25
            int mappedVal = wordWeight % 26;

            // Map the value in reverse order (0 -> 'z', 1 -> 'y', etc.)
            char mappedChar = (char)('z' - mappedVal);

            // Append the mapped character
            result.Append(mappedChar);
        }

        // Return the final concatenated string
        return result.ToString();
    }
}

func mapWordWeights(words []string, weights []int) string {
    // Use a byte slice to efficiently build the result string
    result := make([]byte, 0, len(words))

    // Iterate through all the words
    for _, word := range words {
        wordWeight := 0

        // Iterate through each character of the word
        for i := 0; i < len(word); i++ {
            // Find character index (0-25) by subtracting ASCII of 'a'
            charIndex := word[i] - 'a'
            wordWeight += weights[charIndex]
        }

        // Take modulo 26
        mappedVal := wordWeight % 26

        // Reverse alphabetical mapping: 'z' - mappedVal
        mappedChar := byte('z' - mappedVal)

        // Append the character to our byte slice
        result = append(result, mappedChar)
    }

    // Convert byte slice back to string
    return string(result)
}

# @param {String[]} words
# @param {Integer[]} weights
# @return {String}
def map_word_weights(words, weights)
    result = ""

    # Process each word individually
    words.each do |word|
        word_weight = 0

        # Iterate over each character's byte value
        word.each_byte do |byte|
            # byte of 'a' is 97, so we subtract 97 to get the index
            char_index = byte - 97
            word_weight += weights[char_index]
        end

        # Take the weight modulo 26
        mapped_val = word_weight % 26

        # Convert the reverse alphabetical mapped value back to a character
        # 'z'.ord is 122
        mapped_char = (122 - mapped_val).chr

        # Append the character to the result string
        result << mapped_char
    end

    result
end

impl Solution {
    pub fn map_word_weights(words: Vec<String>, weights: Vec<i32>) -> String {
        // String to store our concatenated results
        let mut result = String::with_capacity(words.len());

        // Iterate over all words
        for word in words {
            let mut word_weight = 0;

            // Calculate the total weight of the word
            for c in word.bytes() {
                // b'a' is the byte value of 'a'
                let char_index = (c - b'a') as usize;
                word_weight += weights[char_index];
            }

            // Modulo 26 operation
            let mapped_val = word_weight % 26;

            // Map the value to reverse alphabetical order (b'z' is 122)
            let mapped_char = (b'z' - mapped_val as u8) as char;

            // Push the character to our result string
            result.push(mapped_char);
        }

        result
    }
}

class Solution {
    fun mapWordWeights(words: Array<String>, weights: IntArray): String {
        // StringBuilder is used to concatenate characters efficiently
        val result = java.lang.StringBuilder()

        // Loop over each word in the array
        for (word in words) {
            var wordWeight = 0

            // Calculate the sum of weights for the characters in the word
            for (c in word) {
                wordWeight += weights[c - 'a']
            }

            // Modulo 26 for the mapping rule
            val mappedVal = wordWeight % 26

            // Calculate reverse alphabetical character starting from 'z'
            val mappedChar = ('z' - mappedVal).toChar()

            // Append the mapped character to the StringBuilder
            result.append(mappedChar)
        }

        // Return the accumulated characters as a string
        return result.toString()
    }
}

class Solution {
    func mapWordWeights(_ words: [String], _ weights: [Int]) -> String {
        // String to collect the mapped characters
        var result = ""

        // Process each word in the array
        for word in words {
            var wordWeight = 0

            // Sum the weights of the characters in the current word
            for char in word {
                // Get the ASCII value of the character and subtract ASCII of 'a'
                let charIndex = Int(char.asciiValue!) - Int(Character("a").asciiValue!)
                wordWeight += weights[charIndex]
            }

            // Take the sum modulo 26
            let mappedVal = wordWeight % 26

            // Map the value using reverse alphabetical order
            let mappedAscii = Int(Character("z").asciiValue!) - mappedVal
            let mappedChar = Character(UnicodeScalar(mappedAscii)!)

            // Append the mapped character
            result.append(mappedChar)
        }

        return result
    }
}