Check if a String Is an Acronym of Words - Practice Coding Problems

Check if a String Is an Acronym of Words - Problem

Array String Easy

You're tasked with creating an acronym validator! Given an array of strings words and a string s, determine if s forms a valid acronym of the words.

An acronym is formed by taking the first character of each word in the given order. For example:

"NASA" could be formed from ["National", "Aeronautics", "Space", "Administration"]
"FBI" could be formed from ["Federal", "Bureau", "Investigation"]

Important: The order matters! "ab" can be formed from ["apple", "banana"], but cannot be formed from ["banana", "apple"].

Return true if s is a valid acronym of words, and false otherwise.

Input & Output

example_1.py — Basic Valid Acronym

$ Input: words = ["alice", "bob", "charlie"], s = "abc"

› Output: true

💡 Note: Taking the first character of each word: 'a' from "alice", 'b' from "bob", 'c' from "charlie" gives us "abc", which matches the input string s.

example_2.py — Invalid Acronym

$ Input: words = ["an", "apple"], s = "a"

› Output: false

💡 Note: The first characters would be 'a' from "an" and 'a' from "apple", giving us "aa". Since "aa" ≠ "a", this is not a valid acronym.

example_3.py — Length Mismatch

$ Input: words = ["never", "gonna", "give", "up"], s = "nggu"

› Output: true

💡 Note: Taking first characters: 'n' from "never", 'g' from "gonna", 'g' from "give", 'u' from "up" gives us "nggu", which exactly matches the input string.

Visualization

Tap to expand

Understanding the Visualization

Input Validation

Check if the number of words matches the length of target acronym

Character Extraction

Take the first character from each word in sequence

Direct Comparison

Compare extracted characters with target string positions

Result

Return true if all characters match, false otherwise

Key Takeaway

🎯 Key Insight: The most efficient approach compares characters directly without building intermediate strings, achieving O(1) space complexity while maintaining O(n) time complexity.

Time & Space Complexity

Time Complexity

⏱️

O(n)

We iterate through the words array once, checking each character. In worst case, we check all n characters

✓ Linear Growth

Space Complexity

O(1)

We only use a constant amount of extra space for variables, no additional data structures

✓ Linear Space

Constraints

1 ≤ words.length ≤ 100
1 ≤ words[i].length ≤ 10
1 ≤ s.length ≤ 100
words[i] and s consist of lowercase English letters
Order matters - acronym must be formed in the exact sequence given

Asked in

G Google 25 a Amazon 18 ⊞ Microsoft 12 Apple 8

The optimal solution uses a one-pass direct comparison approach with O(1) space complexity. Instead of building an intermediate acronym string, we compare each word's first character directly with the corresponding character in the target string. This eliminates unnecessary string operations and provides early termination on the first mismatch.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Comparison (Optimal)	O(n)	O(1)	Compare characters directly without building intermediate string
Brute Force (String Building)	O(n)	O(n)	Build the complete acronym string first, then compare with the input

One-Pass Comparison (Optimal) — Algorithm Steps

Check if the length of words array matches the length of string s
Iterate through the words array with index
For each word, check if it's empty (edge case)
Compare the first character of current word with character at same index in s
If any character doesn't match, return false immediately
If we complete the loop without mismatches, return true

Visualization

Tap to expand

Step-by-Step Walkthrough

Length Check

Verify array length matches string length

Direct Compare

Compare first char of each word with target char

Early Return

Return false immediately on mismatch

Code -

solution.c — C

#include <stdio.h>
#include <string.h>
#include <stdbool.h>

bool isAcronym(char words[][100], int wordCount, char* s) {
    // Check if lengths match
    if (wordCount != strlen(s)) {
        return false;
    }
    
    // Compare characters directly
    for (int i = 0; i < wordCount; i++) {
        if (strlen(words[i]) == 0) { // Handle empty words
            return false;
        }
        if (words[i][0] != s[i]) {
            return false;
        }
    }
    
    return true;
}

int main() {
    char words[3][100] = {"alice", "bob", "charlie"};
    char s[] = "abc";
    printf("%s\n", isAcronym(words, 3, s) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We iterate through the words array once, checking each character. In worst case, we check all n characters

✓ Linear Growth

Space Complexity

O(1)

We only use a constant amount of extra space for variables, no additional data structures

✓ Linear Space

Constraints

1 ≤ words.length ≤ 100
1 ≤ words[i].length ≤ 10
1 ≤ s.length ≤ 100
words[i] and s consist of lowercase English letters
Order matters - acronym must be formed in the exact sequence given

28.5K Views

Medium Frequency

~8 min Avg. Time

890 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

One-Pass Comparison (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler