Question

2828. Check if a String Is an Acronym of Words

中文文档

Description

Given an array of strings words and a string s, determine if s is an acronym of words.

The string s is considered an acronym of words if it can be formed by concatenating the first character of each string in words in order. For example, "ab" can be formed from ["apple", "banana"], but it can't be formed from ["bear", "aardvark"].

Return true_ if _s_ is an acronym of _words_, and _false_ otherwise. _

 

Example 1:

Input: words = ["alice","bob","charlie"], s = "abc"
Output: true
Explanation: The first character in the words "alice", "bob", and "charlie" are 'a', 'b', and 'c', respectively. Hence, s = "abc" is the acronym. 

Example 2:

Input: words = ["an","apple"], s = "a"
Output: false
Explanation: The first character in the words "an" and "apple" are 'a' and 'a', respectively. 
The acronym formed by concatenating these characters is "aa". 
Hence, s = "a" is not the acronym.

Example 3:

Input: words = ["never","gonna","give","up","on","you"], s = "ngguoy"
Output: true
Explanation: By concatenating the first character of the words in the array, we get the string "ngguoy". 
Hence, s = "ngguoy" is the acronym.

 

Constraints:

• 1 <= words.length <= 100
• 1 <= words[i].length <= 10
• 1 <= s.length <= 100
• words[i] and s consist of lowercase English letters.

Solutions

Solution 1: Simulation

We can iterate over each string in the array $words$, concatenate their first letters to form a new string $t$, and then check if $t$ is equal to $s$.

The time complexity is $O(n)$, and the space complexity is $O(n)$. Here, $n$ is the length of the array $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
  }
}

Solution 2: Simulation (Space Optimization)

First, we check if the number of strings in $words$ is equal to the length of $s$. If not, $s$ is definitely not an acronym of the first letters of $words$, and we directly return $false$.

Then, we iterate over each character in $s$, checking if it is equal to the first letter of the corresponding string in $words$. If not, $s$ is definitely not an acronym of the first letters of $words$, and we directly return $false$.

After the iteration, if we haven't returned $false$, then $s$ is an acronym of the first letters of $words$, and we return $true$.

The time complexity is $O(n)$, where $n$ is the length of the array $words$. The space complexity is $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
  }
}