LeetCode 2828. Check if a String Is an Acronym of Words Solution in Java, C++, Python & More | Explanation + Code

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.

PythonJavaC++GoTypeScriptRust

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

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); } }(code-box)

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

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

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

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 } }(code-box)

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).

PythonJavaC++GoTypeScriptRust

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))(code-box)

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; } }(code-box)

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; } };(code-box)

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 }(code-box)

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; }(code-box)

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 } }(code-box)