3838. 带权单词映射

English Version

题目描述

给你一个字符串数组 words，其中每个字符串表示一个由小写英文字母组成的单词。

同时给你一个长度为 26 的整数数组 weights，其中 weights[i] 表示第 i 个小写英文字母的权重。

单词的 权重 定义为其所有字符权重的 总和。

对于每个单词，将其权重对 26 取模，并将结果按字母倒序映射到一个小写英文字母（0 -> 'z', 1 -> 'y', ..., 25 -> 'a'）。

返回一个由所有单词映射后的字符按顺序连接而成的字符串。

 

示例 1：

示例 2：

示例 3：

 

提示：

• 1 <= words.length <= 100
• 1 <= words[i].length <= 10
• weights.length == 26
• 1 <= weights[i] <= 100
• words[i] 仅由小写英文字母组成。

解法

方法一：模拟

我们遍历 $\textit{words}$ 中的每个单词 $w$，计算其权重 $s$，即单词中每个字符的权重之和。然后计算 $s$ 对 26 取模的结果，并将结果映射到一个小写英文字母上，最后连接所有映射后的字符并返回。

时间复杂度 $O(L)$，其中 $L$ 是 $\textit{words}$ 中所有单词的长度之和。空间复杂度 $O(W)$，其中 $W$ 是 $\textit{words}$ 的长度。

Python3

class Solution:
    def mapWordWeights(self, words: List[str], weights: List[int]) -> str:
        ans = []
        for w in words:
            s = sum(weights[ord(c) - ord('a')] for c in w)
            ans.append(ascii_lowercase[25 - s % 26])
        return ''.join(ans)

Java

class Solution {
    public String mapWordWeights(String[] words, int[] weights) {
        var ans = new StringBuilder();
        for (var w : words) {
            int s = 0;
            for (char c : w.toCharArray()) {
                s = (s + weights[c - 'a']) % 26;
            }
            ans.append((char) ('a' + (25 - s)));
        }
        return ans.toString();
    }
}

C++

class Solution {
public:
    string mapWordWeights(vector<string>& words, vector<int>& weights) {
        string ans;
        for (const string& w : words) {
            int s = 0;
            for (char c : w) {
                s = (s + weights[c - 'a']) % 26;
            }
            ans.push_back(char('a' + (25 - s)));
        }
        return ans;
    }
};

Go

func mapWordWeights(words []string, weights []int) string {
	ans := make([]byte, 0, len(words))
	for _, w := range words {
		s := 0
		for i := 0; i < len(w); i++ {
			s = (s + weights[int(w[i]-'a')]) % 26
		}
		ans = append(ans, byte('a'+(25-s)))
	}
	return string(ans)
}

TypeScript

function mapWordWeights(words: string[], weights: number[]): string {
    const ans: string[] = [];
    for (const w of words) {
        let s = 0;
        for (const c of w) {
            s = (s + weights[c.charCodeAt(0) - 97]) % 26;
        }
        ans.push(String.fromCharCode(97 + (25 - s)));
    }
    return ans.join('');
}