Challenge: Counting Words

In the previous lesson, we discovered that our simple space-counting algorithm has fundamental flaws. Counting spaces doesn't accurately count words because:

• Multiple spaces between words throw off the count
• Leading and trailing spaces are counted incorrectly
• The relationship between spaces and words isn't one-to-one

A Better Approach: State Tracking

Instead of counting spaces, let's think about what actually separates words: transitions between whitespace and non-whitespace characters.

Consider this string: "Hello World"

As we iterate through each character:

• H - not a space
• e - not a space
• l - not a space
• l - not a space
• o - not a space
• - is a space (state change!)
• W - not a space (state change! - this is where we enter a new word)
• o - not a space
• r - not a space
• l - not a space
• d - not a space

The key insight is that every time we transition from a space to a non-space character, we're entering a new word.

The Algorithm

We can track state changes using a boolean variable:

1. Keep track of whether the previous character was a space (wasSpace)
2. For each character, check if it's currently a space (isSpace)
3. If wasSpace is true AND isSpace is false, we've entered a new word
4. Increment the word count
5. Update wasSpace to equal isSpace for the next iteration

Let's visualize this with multiple spaces: "Hello World" (two spaces)

Character | isSpace | wasSpace | Action
----------|---------|----------|--------
H         | false   | true*    | wordCount++ (entering first word)
e         | false   | false    | -
l         | false   | false    | -
l         | false   | false    | -
o         | false   | false    | -
(space)   | true    | false    | -
(space)   | true    | true     | -
W         | false   | true     | wordCount++ (entering second word)
o         | false   | false    | -
r         | false   | false    | -
l         | false   | false    | -
d         | false   | false    | -

*Note: We initialize wasSpace to true to correctly count the first word.

Why This Works

This algorithm handles all our edge cases:

• Multiple spaces: Only the transition counts, not each space
• Leading spaces: We only count when transitioning to non-space
• Trailing spaces: No transition occurs, so no count
• Single spaces: Works perfectly as expected

Assignment

Now it's your turn to implement this algorithm! You'll need to:

1. Initialize a wordCount variable
2. Initialize a wasSpace variable (think about what the initial value should be)
3. Loop through each byte in the input
4. Check if the current character is a space
5. Detect state changes and increment the word count
6. Update wasSpace for the next iteration

Remember: you're looking for the transition from space to non-space!