Question

2828. 判别首字母缩略词

English Version

题目描述

给你一个字符串数组 words 和一个字符串 s ，请你判断 s 是不是 words 的 首字母缩略词 。

如果可以按顺序串联 words 中每个字符串的第一个字符形成字符串 s ，则认为 s 是 words 的首字母缩略词。例如，"ab" 可以由 ["apple", "banana"] 形成，但是无法从 ["bear", "aardvark"] 形成。

如果 s 是 words 的首字母缩略词，返回 true_ _；否则，返回_ _false 。

 

示例 1：

输入：words = ["alice","bob","charlie"], s = "abc"
输出：true
解释：words 中 "alice"、"bob" 和 "charlie" 的第一个字符分别是 'a'、'b' 和 'c'。因此，s = "abc" 是首字母缩略词。 

示例 2：

输入：words = ["an","apple"], s = "a"
输出：false
解释：words 中 "an" 和 "apple" 的第一个字符分别是 'a' 和 'a'。
串联这些字符形成的首字母缩略词是 "aa" 。
因此，s = "a" 不是首字母缩略词。

示例 3：

输入：words = ["never","gonna","give","up","on","you"], s = "ngguoy"
输出：true
解释：串联数组 words 中每个字符串的第一个字符，得到字符串 "ngguoy" 。
因此，s = "ngguoy" 是首字母缩略词。 

 

提示：

• 1 <= words.length <= 100
• 1 <= words[i].length <= 10
• 1 <= s.length <= 100
• words[i] 和 s 由小写英文字母组成

解法

方法一：模拟

我们可以遍历数组 $words$ 中的每个字符串，将其首字母拼接起来，得到一个新的字符串 $t$，然后判断 $t$ 是否等于 $s$ 即可。

时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 是数组 $words$ 的长度。

class Solution:
  def isAcronym(self, words: List[str], s: str) -> bool:
    return "".join(w[0] for w in words) == s

class Solution {
  public boolean isAcronym(List<String> words, String s) {
    StringBuilder t = new StringBuilder();
    for (var w : words) {
      t.append(w.charAt(0));
    }
    return t.toString().equals(s);
  }
}

class Solution {
public:
  bool isAcronym(vector<string>& words, string s) {
    string t;
    for (auto& w : words) {
      t += w[0];
    }
    return t == s;
  }
};

func isAcronym(words []string, s string) bool {
  t := []byte{}
  for _, w := range words {
    t = append(t, w[0])
  }
  return string(t) == s
}

function isAcronym(words: string[], s: string): boolean {
  return words.map(w => w[0]).join('') === s;
}

impl Solution {
  pub fn is_acronym(words: Vec<String>, s: String) -> bool {
    words
      .iter()
      .map(|w| w.chars().next().unwrap_or_default())
      .collect::<String>() == s
  }
}

方法二：模拟（空间优化）

我们首先判断 $words$ 中的字符串个数是否等于 $s$ 的长度，如果不等于，那么 $s$ 一定不是 $words$ 的首字母缩略词，直接返回 $false$。

然后我们遍历 $s$ 的每个字符，判断其是否等于 $words$ 中对应字符串的首字母，如果不等于，那么 $s$ 一定不是 $words$ 的首字母缩略词，直接返回 $false$。

遍历结束后，如果没有返回 $false$，那么 $s$ 就是 $words$ 的首字母缩略词，返回 $true$。

时间复杂度 $O(n)$，其中 $n$ 是数组 $words$ 的长度。空间复杂度 $O(1)$。

class Solution:
  def isAcronym(self, words: List[str], s: str) -> bool:
    return len(words) == len(s) and all(w[0] == c for w, c in zip(words, s))

class Solution {
  public boolean isAcronym(List<String> words, String s) {
    if (words.size() != s.length()) {
      return false;
    }
    for (int i = 0; i < s.length(); ++i) {
      if (words.get(i).charAt(0) != s.charAt(i)) {
        return false;
      }
    }
    return true;
  }
}

class Solution {
public:
  bool isAcronym(vector<string>& words, string s) {
    if (words.size() != s.size()) {
      return false;
    }
    for (int i = 0; i < s.size(); ++i) {
      if (words[i][0] != s[i]) {
        return false;
      }
    }
    return true;
  }
};

func isAcronym(words []string, s string) bool {
  if len(words) != len(s) {
    return false
  }
  for i := range s {
    if words[i][0] != s[i] {
      return false
    }
  }
  return true
}

function isAcronym(words: string[], s: string): boolean {
  if (words.length !== s.length) {
    return false;
  }
  for (let i = 0; i < words.length; i++) {
    if (words[i][0] !== s[i]) {
      return false;
    }
  }
  return true;
}

impl Solution {
  pub fn is_acronym(words: Vec<String>, s: String) -> bool {
    if words.len() != s.len() {
      return false;
    }
    for (i, w) in words.iter().enumerate() {
      if w.chars().next().unwrap_or_default() != s.chars().nth(i).unwrap_or_default() {
        return false;
      }
    }
    true
  }
}