Valid Word - Practice Coding Problems

Valid Word - Problem

String Easy

A valid word is like a well-formed password that follows specific rules to ensure it contains meaningful content. Your task is to determine if a given string qualifies as a valid word based on four essential criteria:

Length Requirement: Must contain at least 3 characters
Character Set: Only digits (0-9) and English letters (a-z, A-Z) are allowed
Vowel Requirement: Must include at least one vowel ('a', 'e', 'i', 'o', 'u' and their uppercase versions)
Consonant Requirement: Must include at least one consonant (any English letter that is not a vowel)

Given a string word, return true if the word is valid according to all four rules, otherwise return false.

Example: "abc3" is valid (length ≥ 3, contains vowel 'a', consonant 'b', 'c', and digit '3'), but "a1" is invalid (too short and no consonant).

Input & Output

example_1.py — Valid word with mixed characters

$ Input: word = "234Adas"

› Output: true

💡 Note: The word '234Adas' is valid because: length is 7 (≥3), contains only alphanumeric characters, has vowels 'A' and 'a', and has consonants 'd', 's'.

example_2.py — Invalid word missing vowel

$ Input: word = "b3"

› Output: false

💡 Note: The word 'b3' is invalid because: length is 2 (<3), and it has no vowels (only consonant 'b' and digit '3').

example_3.py — Invalid word with special characters

$ Input: word = "a3$e"

› Output: false

💡 Note: The word 'a3$e' is invalid because it contains the special character '$' which is not alphanumeric, even though it has the required length, vowels, and consonants.

Visualization

Tap to expand

Understanding the Visualization

Character Enters

Each character is examined for validity (alphanumeric check)

Type Classification

Valid letters are classified as vowels or consonants, digits are noted

Flag Updates

Boolean flags are updated based on character classification

Final Decision

After processing all characters, check length and both flags

Key Takeaway

🎯 Key Insight: Single-pass validation with boolean flags is the most efficient approach, checking all criteria simultaneously while iterating through the string only once.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string of length n

✓ Linear Growth

Space Complexity

O(1)

Only using boolean flags and character checks

✓ Linear Space

Constraints

1 ≤ word.length ≤ 20
word consists of English letters (uppercase and lowercase), digits, and/or symbols.
Vowels are: 'a', 'e', 'i', 'o', 'u' and their uppercase versions

Asked in

f Meta 25 a Amazon 20 G Google 15 ⊞ Microsoft 12

The optimal solution uses a single-pass approach with boolean flags to track vowel and consonant presence while validating character types. This achieves O(n) time complexity and O(1) space complexity, making it the most efficient approach for word validation.

Common Approaches

Approach	Time	Space	Notes
✓ Single Pass Validation (Optimal)	O(n)	O(1)	Validate all requirements in one pass using boolean flags
Multiple Pass Validation	O(4n) = O(n)	O(1)	Check each validation rule separately with multiple string traversals

Single Pass Validation (Optimal) — Algorithm Steps

Initialize boolean flags for vowel and consonant detection
Iterate through each character once
For each character: check if valid, if vowel, if consonant
Return true only if length ≥ 3, has vowel, and has consonant

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Set up boolean flags for vowel and consonant tracking

Process Each Character

Check validity, vowel, and consonant status in one pass

Final Validation

Verify all criteria are met after single traversal

Code -

solution.c — C

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

bool isVowel(char c) {
    return c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u' ||
           c == 'A' || c == 'E' || c == 'I' || c == 'O' || c == 'U';
}

bool isValid(char* word) {
    int len = strlen(word);
    if (len < 3) {
        return false;
    }
    
    bool hasVowel = false;
    bool hasConsonant = false;
    
    for (int i = 0; i < len; i++) {
        char c = word[i];
        
        // Check if character is valid (alphanumeric)
        if (!isalnum(c)) {
            return false;
        }
        
        // Check for vowels and consonants
        if (isalpha(c)) {
            if (isVowel(c)) {
                hasVowel = true;
            } else {
                hasConsonant = true;
            }
        }
    }
    
    return hasVowel && hasConsonant;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string of length n

✓ Linear Growth

Space Complexity

O(1)

Only using boolean flags and character checks

✓ Linear Space

Constraints

1 ≤ word.length ≤ 20
word consists of English letters (uppercase and lowercase), digits, and/or symbols.
Vowels are: 'a', 'e', 'i', 'o', 'u' and their uppercase versions

24.6K Views

Medium Frequency

~12 min Avg. Time

847 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

Single Pass Validation (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler