Eject excess space from string in C

Question

I need to write a function which will eject excess space from string in C.

Example:

char s[]="  abcde    abcde    "; 

OUTPUT:

"abcde abcde"

Code:

#include <stdio.h>
#include <ctype.h>
char *eject(char *str) {
  int i, x;
  for (i = x = 0; str[i]; ++i)
    if (!isspace(str[i]) || (i > 0 && !isspace(str[i - 1])))
      str[x++] = str[i];
  if(x > 0 && str[x-1] == ' ') str[x-1] = '\0';
  return str;
}

int main() {
  char s[] = "  abcde    abcde    ";
  printf("\"%s\"", eject(s));
  return 0;
}

This code doesn't work for string " " If this string is found program should print:

""

How to fix this?

Answer 1

You could write two functions which trim leading and trailing whitespace characters.

void trim_front(char *src) {
    size_t i = 0, j = 0;
    while (isspace(src[i])) i++;
    while (i < strlen(src)) src[j++] = src[i++];
    src[j] = '\0';
}

void trim_back(char *src) {
    char *ch = src + strlen(src) - 1;
    while (isspace(*ch)) *ch-- = '\0';
}

If you know you don't have to deal with trailing or leading spaces, your task becomes much simpler.

void reduce_spaces(char *src) {
    size_t i = 0, j = 0;

    for (; i < strlen(src); ++i) {
        if (i == strlen(src) - 1 || 
            (isspace(src[i]) && !isspace(src[i + 1])) ||
            !isspace(src[i])) {
            src[j++] = src[i];
        }
    }

    src[j] = '\0';
}

And testing this:

int main(void) {
    char s[] = "     hello    world     ";

    trim_front(s);
    trim_back(s);
    reduce_spaces(s);

    printf(">%s<\n", s);

    return 0;
}

% gcc test.c
% ./a.out
>hello world<
%

Of course, if you really want to, you can transplant the code from those functions into reduce_spaces, but decomposing a problem into multiple smaller problems can make things much easier.

Answer 2

Basically, you need to remove the consecutive space characters between the words in the input string and all leading and trailing space characters of the input string. That means, write code to remove the consecutive space characters in the input string and while removing the consecutive space characters, remove the leading and trailing space characters completely.

You can do it in just one iteration. No need to write the different functions for removing the leading and trailing spaces of input string, as shown in the other post.

You can do:

#include <stdio.h>
#include <ctype.h>

char * eject (char *str) {
    if (str == NULL) {
        printf ("Invalid input..\n");
        return NULL;
    }

    /* Pointer to keep track of position where next character to be write 
     */
    char * p = str;
    for (unsigned int i = 0; str[i] ; ++i) {
        if ((isspace (str[i])) && ((p == str) || (str[i + 1] == '\0') || (str[i] == (str[i + 1])))) {
            continue;
        }
        *p++ = str[i];
    }

    /* Add the null terminating character. 
     */
    *p = '\0';
    return str;
}

int main (void) {
  char s[] = "  abcde    abcde    ";
  printf("\"%s\"\n", eject(s));

  char s1[] = "      ";
  printf("\"%s\"\n", eject(s1));

  char s2[] = "ab  yz   ";
  printf("\"%s\"\n", eject(s2));

  char s3[] = "  ddd xx  jj m";
  printf("\"%s\"\n", eject(s3));

  char s4[] = "";
  printf("\"%s\"\n", eject(s4));

  return 0;
}

Output:

# ./a.out
"abcde abcde"
""
"ab yz"
"ddd xx jj m"
""

Answer 3

A slightly more advanced answer just for reference - suppose you were tasked in writing a professional library for the use in real world programs. Then one would first list all requirements that make sense:

• It's good practice to treat strings as "immutable" - that is, build up a new string based on the old one rather than in-place replacement.
• Take the destination string as parameter but also return a pointer to it (similar to strcpy etc functions).
• In case of empty strings, set the destination string empty too.
• Remove all "white space" not just the ' ' character.
• Instead of always inserting a space character after each word, why not insert a variable delimiter? Might as well be something like , or ;.
• No delimiter should be inserted after the last word.
• The algorithm should only traverse the data once for performance reasons. That is, internal calls like strlen etc are unacceptable.
• Byte by byte iteration is fine - we need not care about alignment.

Then we might come up with something like this:

#include <ctype.h>
#include <stdbool.h>
#include <stdio.h>

char* trim_delimit (char* restrict dst, const char* restrict src, char delim)
{
  char* start = dst;
  *dst = '\0';
  
  bool remove_spaces = true;
  char* insert_delim_pos = NULL;
  
  for(; *src != '\0'; src++)
  {
    if(remove_spaces)
    {
      if(!isspace(*src))
      {
        remove_spaces = false;
        if(insert_delim_pos != NULL)
        {
          // we only get here if more words were found, not yet at the end of the string
          *insert_delim_pos = delim; 
          insert_delim_pos = NULL;
        }
      }
    }

    if(!remove_spaces)
    {
      if(isspace(*src))
      {
        remove_spaces = true;
        insert_delim_pos = dst; // remember where to insert delimiter for later
      }
      else
      {
        *dst = *src;
      }
      dst++;
    }
  }

  return start;
}

Test cases:

int main (void)
{
  char s[]="  abcde    abcde    "; 
  char trimmed[100];

  puts(trim_delimit(trimmed, s, ' '));
  puts(trim_delimit(trimmed, "", ' '));
  puts(trim_delimit(trimmed, s, ';'));
}

Output:

abcde abcde

abcde;abcde