Erase the displayed characters - c

Question

I'm doing the exercises in the "C Programming Language" 2nd Edition by Brian W. Kernighan & Dennis M. Ritchie.
Exercise 1.9 confused me. So here it is:
"Write a program to copy its input to output, replacing each string of one more blanks by a single blank".
I puzzled over this. I post my question here because other learners didn't do this exercise the same as I want to do it. Here it is, using - to represent a blank:
Input: ----hello
Output: -hello
But I want this:
Input: ----hello
Output: ----hello
Input: ----
Output: -
So here is my program:
#include <stdio.h>
#include <stdlib.h>
int main()
{
int character; /* input character */
int non_blank = 0; /* is any non blank character */
while ((character = getchar()) != EOF) {
if (character != '\n') {
putchar(character);
if (character != ' ') {
non_blank = 1;
}
}
else {
if (non_blank == 0 ) {
putchar('\b'); /* go to previous line (blabla\n|cursor|) (blabla|cursor|\n) */
putchar('\r'); /* carriage return */
putchar(' '); /* put one space */
putchar('\0'); /* and put the end of line */
}
non_blank = 0;
}
}
return EXIT_SUCCESS;
}
But spaces aren't erased.
Input: ------|\n
Output: -|-----
Here is my experiment with escape sequences:
#include <stdio.h>
#include <stdlib.h>
int main()
{
printf("bbbbbbbbbbbbbbb");
putchar('\b'); /* jump to previous line */
putchar('\r');
putchar('b');
putchar('\0');
return EXIT_SUCCESS;
}
| is a cursor.
Output: b|
But when I'll add the newline character, it doesn't work. How to make it work with newline characters?

Answer 1

The problem with your code is that you are printing the characters as soon as you process them, and you try to erase them once you detect they have to be compressed to one space.
Your approach is valid, but you must know first that \b only makes the cursor to go back one space (without erasing), so the right approach would be to emit \b \b (a backspace, a space to overwrite the character and another backspace to leave the cursor in a correct position)
The other approach is to wait to print anything until we know if the line terminates with a nonblank string or it finishes with only a \n char.
The following code counts the blank characters and manages two states to cope with that. For sure you will be able to follow the code, and I have tried to document it with comments.
#include <stdio.h>
int main()
{
int c;
int state = 0;
int nblanks = 0;
/* read chars up to EOF */
while((c = getchar()) != EOF) {
switch (state) {
case 0: /* no nonblank character read */
switch (c) {
/* accumulate number of blanks to be printed in case
* we see a nonblank char before \n */
case ' ': nblanks++; break;
/* in this case we have seen nblanks before a \n, so
* we have to print only one blank and \n */
case '\n':
puts(" "); /* just one space */
nblanks = 0; /* reset counter */
break;
/* nonblank char */
default:
/* print all the blanks up to here */
printf("%*s%c", nblanks, "", c);
state = 1; /* switch state */
break;
} /* switch */
break;
/* we have read at least a nonblank char, so we must
* echo the line until the end. */
case 1:
if (c == '\n') {
state = 0;
nblanks = 0;
} /* if */
putchar(c);
break;
} /* switch */
} /* while */
} /* main */
It's completely compatible with K&R second edition, so you only have to compile it and run.
Perhaps the most difficult statement to follow is the printf() line in the middle. The asterisk * allows me to specify the width of the field with a printf parameter, and passing an empty string "" allows me to print a string with nblanks spaces. The final %c format is to print the nonblank character just read. This leads to a compact and efficient code.
Last, some wrong ideas you have:
\b only goes back one character in the terminal (one character, not one line). I't only works when printing to a terminal or to a printer. It doesn't work on a file (the file will get the backspaces as normal characters inside)
\r makes the cursor to go to the first display column. This works only on the screen and in a printer. It does not work in a file, where it gets included as a normal character.
\0 Is a character used by C programs to finish character strings (to know where in memory they finish) It is not a special character for an output device, and it does nothing (it is the ASCII NUL character, does nothing on the output terminal)
finally, if you try to follow the \b \b approach on a printer, it will not erase anithing as the space doesn't erase what has already been printed. So then, you have to follow the second approach.

Answer 2

the desired algorithm should be something like:
implement a state machine with two states. NotInSpaces and InSpaces
(with just two states, a boolean would work)
no special treatment for '\n'
set state to NotInSpaces
Loop: (exit loop on EOF)
getchar
if char is space
then if state is NotInSpaces
then set state to InSpaces
output space
endif
else
output char
endif
end Loop:
output '\n' // to force output buffer flush