Role of else if (state == OUT) in C word count - c

Question

I'm learning C following the book "The C Programming Language" - K&R;
I found myself stuck in the understanding of the role of else if (state == OUT):
#define IN 1
#define OUT 0
main ()
{
int c, nw, state;
state = OUT;
nw = 0;
while ((c = getchar()) != EOF) {
if (c == ' ' || c == '\n' || c == '\t')
state = OUT;
else if (state == OUT) {
state = IN;
++nw;
}
}
printf ("%d", nw);
}
In the word counting program, I mean, in the way I read it there must be something I am doing wrong, because I fail to understand why this makes the difference, from simple else, since state = OUT is already default condition; but in practice I observe that it does, because if I write just else
then the statement state = IN; ++nw will count characters and not words;
from the way I read it, the loop is saying that for each input character (stored in the variable c), if it is a space, a new line, or a tab, then it's value is zero, everything else, will be 1, so I fail to see how it is grouping characters into words, because state was OUT already before the loop, so how is else if (state == OUT) getting the program to put the characters into one word?
I have been thinking whole night about it but I couldn't find an answer in my thoughts, nor in the book

Answer 1

To count words, we want to increment the count, with ++nw, only once per word.
If we write:
if (c == ' ' || c == '\n' || c == '\t')
state = OUT;
else {
state = IN;
++nw;
}
then ++nw will be executed every time c is not one of the white-space characters space, new-line, or tab. However, by writing:
if (c == ' ' || c == '\n' || c == '\t')
state = OUT;
else if (state == OUT) {
state = IN;
++nw;
}
then ++nw will not be executed when we are already in a word (state is IN). It will be executed only when we are out of a word (state is OUT) and are going into a new word (because c is not one of the white-space characters). Thus, ++nw is executed only when we start a new word, not for each character in the word.

Answer 2

cccc cc c c cccccc cc
^ ^ ^ ^ ^ ^
| | | | | |
These are the two ways to count words - only the transitions count.
Geometrically this is easy and intuitive: every c that has a white space to its left.
But if you step (once, blindly) through each element, you only have to store the last character, which corresponds to the "left". This minimal memory makes this algorithm a state machine.
When you hit a letter, you only count it if you come from OUTside a word, but at the same time set the state to INside, so the next letter does not get counted. The next space then will set the trigger to "OUT".

Answer 3

This statement is checking character (c) values:
if (c == ' ' || c == '\n' || c == '\t')
and if any character (c) is a space or newline or tab then the state value is changed to OUT.
This statement else if (state == OUT) is checking the value of state whenever a character (c) is not a space, newline or tab.
The assumption of the program is that all words are separated by a space, newline or tab character and is at least one character long.
Punctuation characters such as :;,.?! etc. are included as legitimate characters for words.
Use of getchar ensures that at least one character is read.
The program will complete when it detects an End Of File character i.e. no further input.
The word count is increased on the first character that is not space, newline or tab.

Answer 4

This program counts words by modeling a very simple state machine with two states:
OUT: We have not read a character that is part of a word
IN: We have read a character that is part of a word
The number of words is determined by the number of times we transition from the OUT to the IN state. Given an output like "This is a test", the transitions work like this:
This is a test
^+++v--^+v^v----^+++
where + represents the IN state, - represents OUT state, ^ represents the transition from OUT to IN, and v represents the transition from IN to OUT. The number of words is equal to the number of times we see ^.
In order to know whether or not we're making the transition from the OUT to the IN state, we have to check the current value of state when we see a non-whitespace character; hence, the
else if (state == OUT)
as the alternate branch instead of a plain else. Otherwise we'd increment nw for every non-whitespace character, rather than on the transition from OUT to IN.