Thread: program logic

You have to be careful not to print anything until all of the blanks have been taken in. Then you print a single blank and the next nonblank character. If there are no blanks, then you need to print every time. This logic really calls for an if..else if..else sequence:

Code:

/*
* Copy input to output, compact whitespace
*/
#include <stdio.h>

int main(void)
{
    int c;
    int done;
    int blank;
    
    done = 0;
    blank = 0;
    
    while ( done == 0 )
    {
        c = getchar();

        if ( c == EOF )
            done = 1;
        else if ( c == ' ' )
            blank++;
        else if ( blank > 0 ) {
            blank = 0;
            putchar( ' ' );
            putchar( c );
        }
        else
            putchar( c );
    }
    
    return 0;
}

1) Setup a loop testing if c isn't EOF, then inside of the loop test if c is a blank.
2) If c is a blank, continue fetching the chars until c is a non-blank.
3) Print a single blank, and the non-blank c.

Code:

#include <stdio.h>
int main()
{
  int c;

  while( (c = getchar()) != EOF)
    {
      if(c == ' ')
	{
	  while( (c = getchar()) == ' ')
	    ;
	  putchar(' ');
	}
      	putchar(c);
    }

  return 0;
}

HTH,

But what if you get an EOF in the inner getch() ?
Kaputt?


EDIT: not getch(), getchar() :- )

Originally posted by Prelude
You have to be careful not to print anything until all of the blanks have been taken in. Then you print a single blank and the next nonblank character. If there are no blanks, then you need to print every time. This logic really calls for an if..else if..else sequence:

Code:

/*
* Copy input to output, compact whitespace
*/
#include <stdio.h>

int main(void)
{
    int c;
    int done;
    int blank;
    
    done = 0;  
    blank = 0;
    
    while ( done == 0 )  // This can be simply changed to (!done)
    {
        c = getchar();

        if ( c == EOF )
            done = 1;
        else if ( c == ' ' )    
            {                          // close... add the following
                if (blank == 0)  
                    putchar(c);
            }

            blank++;
        else if ( blank > 0 )    // remove these lines 
        {
            blank = 0;
            putchar( ' ' );
            putchar( c );
        }
        else
            blank = 0;    // move this line here 
            putchar( c );
    }
    
    return 0;
}

See, lots of ways to do this...

Using your original concept, all you forgot is that you are looking for a space or not space. Only two conditions (3 if you consider the EOF)

If not a space,
-- print the char
-- flag 'no space'
If a space,
-- if not flagged, output the space
-- flag the space

Originally posted by C-learning
But what if you get an EOF in the inner getch() ?
Kaputt?


EDIT: not getch(), getchar() :- )

Hmm, it all depends on whether stdin is a file or the keyboard, if it's the former, everything will be printed as expected.
OTOH, if you're entering from the keyboard, a garbage value will be displayed.

To fix that add if(c!=EOF) before putchar(c); line.

As a function:

Code:

char * thin(char * dest, const char * source, char single)
{
 char * s, * d = dest;

 int flag = 2;

  for(s = (char*)source; *s != 0; ++s)
 {
  if(*s == single)
   --flag;
  else
   flag = 2;

  if(flag > 0) *(d++) = *s;
 }

 *d = 0;

 return dest;
}


char * thin_space(char * dest, const char * source)
{
 return thin(dest, source, ' ');
} 

int main()
{
 char buffer[100] = "hello          world.";

 printf("%s", thin_space(buffer, buffer));

 return 0;
}

>See, lots of ways to do this...
Indeed. Just out of curiosity, were you correcting me or making a point to the OP? Hard to tell.

Originally posted by Prelude
>See, lots of ways to do this...
Indeed. Just out of curiosity, were you correcting me or making a point to the OP? Hard to tell.

Nope, I wasn't correcting you. More making a point. I simply preferred putting the multi-test within the Space test

>> Why do you cast away the const of source here?

Because it's rather hard to increment a contant pointer.

>> source is no longer const at all...

True. Ordinarily, 'source' *would* be constant, but I chose to use it as both 'source' and 'dest'.

While it's true that overlapping the two seems risky, it's not as long as you design functions to handle it properly. In some cases, reverse copying or other approaches are necessary, but in this one, we know that 'dest' will always be shorter or equal to 'source'. Had the function been designed to EXPAND segments of the string, on the other hand, it would've needed a different design.

Still, good points. : - )

const char *p;
p++ is allowed, *p++ isn't
char * const p;
p++ isn't allowed, *p++ is

I think you may have this a little mixed up Salem:

Given

const char *p;
p++ increments the pointer, all is well.
*p++ increments the pointer, not the data pointed to because ++ has higher precedence than *.
(*p)++ is not legal because the data pointed to is const.

char *const p;
p++ is illegal because it modifies a const pointer.
*p++ is also illegal because it modifies a const pointer.
(*p)++ is legal, the data pointed to is not const.

Whoops. I can't believe I said that.

It's been a long week.