Number of Valid Words in a Sentence - Practice Coding Problems

Number of Valid Words in a Sentence - Problem

String Easy

Imagine you're building a smart text processor that needs to validate words in sentences! 🔍

You're given a sentence containing lowercase letters, digits, hyphens, punctuation marks (!, ., ,), and spaces. Your task is to count how many valid words exist in this sentence.

A word is considered valid if it follows these strict rules:

Character Rule: Only lowercase letters, hyphens, and punctuation allowed (no digits!)
Hyphen Rule: At most one hyphen, and it must be surrounded by lowercase letters ("a-b" ✅, "-ab" ❌, "ab-" ❌)
Punctuation Rule: At most one punctuation mark, and it must be at the very end ("hello!" ✅, "he!llo" ❌)

Examples of valid words: "a-b.", "hello", "world!", "x-y", "!"

Goal: Return the total count of valid words in the sentence.

Input & Output

example_1.py — Basic Mixed Sentence

$ Input: sentence = "cat and dog"

› Output: 3

💡 Note: All three tokens 'cat', 'and', and 'dog' are valid words (only lowercase letters, no digits, no hyphens, no punctuation)

example_2.py — Complex Validation

$ Input: sentence = "!this 1-s b8d!"

› Output: 2

💡 Note: '!this' is valid (punctuation only at end), '1-s' is invalid (contains digit), 'b8d!' is invalid (contains digit)

example_3.py — Hyphen Edge Cases

$ Input: sentence = "alice and bob are playing stone-game10"

› Output: 5

💡 Note: 'alice', 'and', 'bob', 'are', 'playing' are valid. 'stone-game10' is invalid due to digit '1' and '0'

Constraints

1 ≤ sentence.length ≤ 1000
sentence consists of lowercase letters, digits, hyphens, punctuation marks, and spaces only
There are no leading or trailing spaces in sentence
Each token is separated by at least one space

Visualization

Tap to expand

Understanding the Visualization

Token Splitting

Sentence 'cat and-dog!' gets split into ['cat', 'and-dog!']

Rule Inspection

Each token flows through validation: digits check, hyphen rules, punctuation rules

Quality Control

Invalid tokens (with digits, bad hyphens, misplaced punctuation) get rejected

Valid Count

Only tokens passing all quality checks contribute to the final count

Key Takeaway

🎯 Key Insight: Single-pass validation is like having an expert inspector who can check multiple quality standards simultaneously, making the process both faster and more efficient than multiple separate inspections.

Asked in

f Meta 12 G Google 8 a Amazon 6 ⊞ Microsoft 4

The optimal approach uses a single-pass validation strategy. We split the sentence into tokens and validate each token in O(n) time by checking all rules (digits, hyphens, punctuation) simultaneously as we scan each character once. This eliminates the need for multiple passes and achieves the best possible time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Multiple Validation Passes)	O(n * m)	O(k)	Check each validation rule separately for every token
Single Pass Validation (Optimal)	O(n)	O(k)	Validate all rules simultaneously in one pass through each token

Brute Force (Multiple Validation Passes) — Algorithm Steps

Split sentence by spaces to get tokens
For each token, check if it contains digits
For each token, count hyphens and validate positions
For each token, count punctuation and validate positions
Count tokens that pass all validation checks

Visualization

Tap to expand

Step-by-Step Walkthrough

Split Sentence

Break sentence into individual tokens

Check Digits

Scan each token for any digit characters

Check Hyphens

Count hyphens and validate their positions

Check Punctuation

Count punctuation marks and validate positions

Code -

solution.c — C

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

bool hasDigits(const char* token) {
    for (int i = 0; token[i]; i++) {
        if (isdigit(token[i])) return true;
    }
    return false;
}

bool validateHyphens(const char* token) {
    int hyphenCount = 0;
    int hyphenPos = -1;
    int len = strlen(token);
    
    for (int i = 0; i < len; i++) {
        if (token[i] == '-') {
            hyphenCount++;
            hyphenPos = i;
        }
    }
    
    if (hyphenCount > 1) return false;
    if (hyphenCount == 1) {
        if (hyphenPos == 0 || hyphenPos == len - 1) return false;
        if (!islower(token[hyphenPos - 1]) || !islower(token[hyphenPos + 1])) {
            return false;
        }
    }
    
    return true;
}

bool validatePunctuation(const char* token) {
    int punctCount = 0;
    bool lastIsPunct = false;
    int len = strlen(token);
    
    for (int i = 0; i < len; i++) {
        char c = token[i];
        if (c == '!' || c == '.' || c == ',') {
            punctCount++;
            lastIsPunct = (i == len - 1);
        }
    }
    
    if (punctCount > 1) return false;
    if (punctCount == 1 && !lastIsPunct) return false;
    
    return true;
}

int countValidWords(char* sentence) {
    char* token = strtok(sentence, " ");
    int validCount = 0;
    
    while (token != NULL) {
        if (!hasDigits(token) && validateHyphens(token) && validatePunctuation(token)) {
            validCount++;
        }
        token = strtok(NULL, " ");
    }
    
    return validCount;
}

int main() {
    char sentence[1000];
    fgets(sentence, sizeof(sentence), stdin);
    
    // Remove quotes and newline
    int len = strlen(sentence);
    if (sentence[len-1] == '\n') sentence[len-1] = '\0';
    if (sentence[0] == '"' && sentence[strlen(sentence)-1] == '"') {
        sentence[strlen(sentence)-1] = '\0';
        memmove(sentence, sentence + 1, strlen(sentence));
    }
    
    printf("%d\n", countValidWords(sentence));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * m)

n tokens, each scanned m times (once per rule), where m is average token length

✓ Linear Growth

Space Complexity

O(k)

k is the number of tokens after splitting (for storing the split result)

✓ Linear Space

28.4K Views

Medium Frequency

~15 min Avg. Time

854 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Multiple Validation Passes) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler