Top Coding Interview Question – Solved

```
To solve the problem of determining the number of valid words in a given string, you need to begin by understanding what makes a word “valid” based on the conditions provided. According to the prompt, a word is considered valid if it satisfies all of the following criteria:
1. It must be at least 3 characters long.
2. It must contain only alphanumeric characters (i.e., letters and digits).
3. It must contain at least one vowel.
4. It must contain at least one consonant.

Let’s break this down and guide our thinking around each requirement step by step.

First, consider the input. You are given a string `s` that may contain multiple words. Words are usually separated by whitespace, such as spaces or newline characters. So your first task is to split the input string into individual components (words) using whitespace as the delimiter. Keep in mind that there may be multiple spaces between words, and some entries might even be empty or contain only punctuation.

Next, once you have the list of potential words, you need to evaluate each one to determine whether it meets the validity criteria.

Start by examining the length of each word. The first filter should be whether the word has at least three characters. Any word shorter than that can be skipped immediately without further checks, since it already violates the minimum length requirement.

Next, check whether the word consists only of alphanumeric characters. Alphanumeric characters include all letters (uppercase and lowercase) and digits (0–9). If a word contains any non-alphanumeric characters like punctuation marks, symbols, or whitespace, it should be rejected. This ensures that words like “he!lo”, “23@” or “nice#” are not considered valid even if they contain vowels or consonants.

Once a word passes the length and alphanumeric checks, you can move on to the core content validation—checking for at least one vowel and at least one consonant. Vowels are typically defined as the characters 'a', 'e', 'i', 'o', and 'u'. Since the word may be in mixed case (uppercase or lowercase), you should treat the check in a case-insensitive way, meaning both 'A' and 'a' should count as vowels.

To perform this check, you’ll want to iterate through each character in the word and determine whether it is a vowel or a consonant. Digits should be ignored for both counts, since a valid word must contain letters—both vowels and consonants. So for example, the word “123abc” is valid if it has at least one vowel and one consonant among the letters.

For each character:
- If it’s a letter and a vowel, mark that a vowel has been found.
- If it’s a letter and not a vowel (i.e., a consonant), mark that a consonant has been found.
- If it’s a digit, ignore it for the vowel/consonant checks.

Once you confirm that both a vowel and a consonant exist in the word, and it passed the earlier length and alphanumeric checks, you can count it as a valid word.

This process should be repeated for each word in the original string. At the end of the iteration, the total count of valid words gives the desired output.

Now, consider a few examples to clarify the logic:
Take the word “This”. It is 4 characters long, contains only letters, includes the vowel ‘i’ and consonants ‘t’, ‘h’, and ‘s’. Therefore, it’s valid.

Consider “234”. It is 3 characters long and alphanumeric, but contains no letters at all—only digits—so it has neither vowels nor consonants. Hence, it's invalid.

Now take “an”. It contains both a vowel and a consonant but is only two characters long, which makes it invalid.

When building the full solution, make sure to handle edge cases like:
- Words with mixed case letters.
- Words with only digits or symbols.
- Words that are long enough but include special characters like punctuation.
- Repeated whitespace or leading/trailing spaces.

This approach ensures a clean, systematic validation of each word according to the problem rules, resulting in an efficient and accurate word count tool.
```