# 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$.

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 {
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;
}
};

• class Solution:
def isAcronym(self, words: List[str], s: str) -> bool:
return "".join(w[0] for w in words) == 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
}
}