README_EN.md

2047. Number of Valid Words in a Sentence

中文文档

Description

A sentence consists of lowercase letters ('a' to 'z'), digits ('0' to '9'), hyphens ('-'), punctuation marks ('!', '.', and ','), and spaces (' ') only. Each sentence can be broken down into one or more tokens separated by one or more spaces ' '.

A token is a valid word if:

• It only contains lowercase letters, hyphens, and/or punctuation (no digits).
• There is at most one hyphen '-'. If present, it should be surrounded by lowercase characters ("a-b" is valid, but "-ab" and "ab-" are not valid).
• There is at most one punctuation mark. If present, it should be at the end of the token.

Examples of valid words include "a-b.", "afad", "ba-c", "a!", and "!".

Given a string sentence, return the number of valid words in sentence.

 

Example 1:

Input: sentence = "cat and  dog"
Output: 3
Explanation: The valid words in the sentence are "cat", "and", and "dog".

Example 2:

Input: sentence = "!this  1-s b8d!"
Output: 0
Explanation: There are no valid words in the sentence.
"!this" is invalid because it starts with a punctuation mark.
"1-s" and "b8d" are invalid because they contain digits.

Example 3:

Input: sentence = "alice and  bob are playing stone-game10"
Output: 5
Explanation: The valid words in the sentence are "alice", "and", "bob", "are", and "playing".
"stone-game10" is invalid because it contains digits.

Example 4:

Input: sentence = "he bought 2 pencils, 3 erasers, and 1  pencil-sharpener."
Output: 6
Explanation: The valid words in the sentence are "he", "bought", "pencils,", "erasers,", "and", and "pencil-sharpener.".

 

Constraints:

• 1 <= sentence.length <= 1000
• sentence only contains lowercase English letters, digits, ' ', '-', '!', '.', and ','.
• There will be at least 1 token.

Solutions

Python3

class Solution:
    def countValidWords(self, sentence: str) -> int:
        def check(token):
            hyphen = False
            for i, c in enumerate(token):
                if c.isdigit() or (c in '!.,' and i < len(token) - 1):
                    return False
                if c == '-':
                    if hyphen or i == 0 or i == len(token) - 1 or not token[i - 1].islower() or not token[i + 1].islower():
                        return False
                    hyphen = True
            return True

        return sum(check(token) for token in sentence.split())

Java

class Solution {
    public int countValidWords(String sentence) {
        int ans = 0;
        for (String token : sentence.split(" ")) {
            if (check(token)) {
                ++ans;
            }
        }
        return ans;
    }

    private boolean check(String token) {
        int n = token.length();
        if (n == 0) {
            return false;
        }
        boolean hyphen = false;
        for (int i = 0; i < n; ++i) {
            char c = token.charAt(i);
            if (Character.isDigit(c) || (i < n - 1 && (c == '!' || c == '.' || c == ','))) {
                return false;
            }
            if (c == '-') {
                if (hyphen || i == 0 || i == n - 1 || !Character.isLetter(token.charAt(i - 1)) || !Character.isLetter(token.charAt(i + 1))) {
                    return false;
                }
                hyphen = true;
            }
        }
        return true;
    }
}

TypeScript

function countValidWords(sentence: string): number {
    let words = sentence.trim().split(/\s+/);
    let ans = 0;
    for (let word of words) {
        if (isValied(word)) {
            ans++;
        }
    }
    return ans;
}

function isValied(str: string): boolean {
    let n = str.length;
    let hasLine = false;
    for (let i = 0; i < n; i++) {
        const char = str.charAt(i);
        if (/^[0-9]$/.test(char)) {
            return false;
        }
        if (char == "-") {
            if (hasLine) return false;
            else {
                hasLine = true;
            }
            let pre = str.charAt(i - 1),
                post = str.charAt(i + 1);
            if (!/^[a-z]$/g.test(pre) || !/^[a-z]$/g.test(post)) {
                return false;
            }
        }
        if (/^[\!\.\,\s]$/.test(char) && i != n - 1) {
            return false;
        }
    }
    return true;
}

...