CareerCup

void remove_spaces(char* string) {
  if (string == NULL) return;
  char* copy_to = string;
  char* copy_from = string;
  while (*copy_from != '\0') {
    if (*copy_from == ' ') { copy_from++; continue; }
    *copy_to = *copy_from;
    copy_from++;
    copy_to++;
  } 
  *copy_to = '\0';
}

void removeSpaces(char* source){
    if(source == NULL)
        return;
    char* i = source;
    char* j = source;
    while(*j){
        *i = *j++;
        if(*i != ' '){
            i++;
        }
    }
    *i = '\0';
}

// Assumes in-place removal of spaces
// Time O(n) - Space O(1)
void removeSpaces(char* s) {
  if (!s) {
    return;
  }
  char* nonwhite = s - 1;
  char* itr = s;
  while (*itr) {
    if (*itr != ' ') {
      *(++nonwhite) = *itr;
    }
    ++itr;
  }
  *(++nonwhite) = '\0';
}

O(n):

remove_spaces(char *str) {
	char *temp;
	char *cur;

	cur = str;

	while (*cur != '\0' && *cur != ' ' ) {
		cur++;
	}

	temp = cur;

	while (temp != '\0') {
		if (temp != ' ')
			*cur = *temp;
			cur++;
		}
		temp++;
	}
	*cur = '\0';
}

char *trimspace(char *str)
{
char *str1,*str2;
str1=str;
str2=str;
while(*str1)
{
if (*str1!=' ')
{
*str2=*str1;
str1++;
str2++;
}
str1++;
}
*str2='\0'
return str2;
}

#include<stdio.h>
#include<conio.h>
int main()
{
char ch[]="ram is a good boy";
int i;
for(i=0;i<20;i++)
{
if(ch[i]==' ')
continue;
else
printf("%c",ch[i]);
}
getch();
return 0;
}

private static void RemoveSpaces()
{
string temp = "nayni sh sdfg j k k";
char[] myArr = temp.ToCharArray();
SpaceCheck(ref myArr, 0, 0);
foreach (char item in myArr)
{
Console.Write(item);
}
}


private static void SpaceCheck(ref char[] myArr, int i, int j)
{
if (i < myArr.Length)
{
if (Char.IsWhiteSpace(myArr[i]))
{
if (!Char.IsWhiteSpace(myArr[j]))
{
j++;
SpaceCheck(ref myArr, i, j);
}
else
{
i++;
SpaceCheck(ref myArr, i, j);
}
}
else if (!Char.IsWhiteSpace(myArr[i]))
{
if (Char.IsWhiteSpace(myArr[j]))
{
char temp;
temp = myArr[i];
myArr[i] = myArr[j];
myArr[j] = temp;
i++; j++;
SpaceCheck(ref myArr, i, j);
}
else
{
j++; i++;
SpaceCheck(ref myArr, i, j);
}
}
}
}

private static void RemoveSpaces()
{
string temp = "nayni sh sdfg j k k";
char[] myArr = temp.ToCharArray();
SpaceCheck(ref myArr, 0, 0);
foreach (char item in myArr)
{
Console.Write(item);
}
}

private static void RemoveSpaces()
{
string temp = "fsdkjgfsd sds aads dd f ";
char[] myArr = temp.ToCharArray();
StringBuilder sb = new StringBuilder();
foreach (char item in myArr)
{
if(!Char.IsWhiteSpace(item))
{
sb.Append(item);
}
}
Console.WriteLine(sb);
}

int _tmain(int argc, _TCHAR* argv[])
{
int i=0,j=0;
char str[]="spa ci ous string occ ur ed";
while(i<strlen(str))
{
if(str[i]==' ')
{
i++;


}
else
{
str[j]=str[i];
++i;
++j;

}

}
str[j]='\0';
std::cout<<str;
getch();
return 0;
}

private static String removeSpaces(String str)
{
String res = new String();

for(int i=0; i<str.length(); i++)
{
if(!(str.charAt(i)==' '&& (i<str.length()-1)))
{
res += str.charAt(i);
}

}
return res;
}

void reverse_String(char *str) {
        int len = strlen(str) - 1;
        int i = 0, j = 0;

       for(i = 0; i < n; i++) {
            if(str[i] == ' ' | str[i] == '\t\) {}
            else {
                          str[j] = str[i];
                          j++;
           }
        }

        str[j] = '\0';
}

void remove_space_from_a_string(char *oldstring, char *newstring)
{
while(*oldstring !='\0')
{ if(*oldstring != ' ')
{ *newstring = *oldstring;
newstring++; oldstring++;
}
else
oldstring++;
}
*newstring = '\0 ';
}

The in-place solution has complexity of O(N^2) because you have to move the characters following a space after it's removed. (N characters moved N times).

By copying the string we don't have to move any characters so the solution is O(N). Only one pass is necessary if we can return the copied string, otherwise a second pass is necessary to copy it back to the original. Either way it's still O(N).

{{
void remSpace(char*str)
{
int index = 0;
for(int i =0;str[i] ;i++)
{
if(str[i] != ' ')
str[index++]= str[i];
}
str[index] = '\0';
}
}}

{{

void remSpace(char*str)
{
int index = 0;
for(int i =0;str[i] ;i++)
{
if(str[i] != ' ')
str[index++]= str[i];
}
str[index] = '\0';
}

}}

{{
void remSpace(char*str)
{
int index = 0;
for(int i =0;str[i] ;i++)
{
if(str[i] != ' ')
str[index++]= str[i];
}
str[index] = '\0';
}
}}

void remove_spaces(char* str)
{
	int count = 0;
	for(int i = 0; str[i] != '\0'; ++i)
	{
		if(str[i] == ' '){ ++count; }
		else { str[i - count] = str[i]; }
	}
}

char* nospace(char *s){
	char *buffer = malloc(strlen(s));
	int i=0;
	while (*s != '\0'){
		if(*s != ' '){
			buffer[i] = *s;
			i++;
		}
		*s++;		
	}
	return buffer;
}

Time: O(n) Space: O(1)

Java solution

String s="yes I can delete spaces";
		StringBuilder sb=new StringBuilder(s);
		int numberOfDeletes=0;
		for(int i=0; i<s.length()-1; i++)
		{
			if(s.charAt(i)==' ')
			{
				sb.deleteCharAt(i-numberOfDeletes);
				numberOfDeletes++;
			}
		}
		
		s=sb.toString();
		System.out.println(s);

A python solution:

def removeSpaces(inputString):
	length=len(inputString)
	numberOfdeletions=0
	for i in range(0,length):
		if inputString[i-numberOfdeletions]==' ':
			print "here"
			nwLength=length-numberOfdeletions
			inputString=inputString[:i-numberOfdeletions]+inputString[i+1-numberOfdeletions:]
			numberOfdeletions+=1
			print numberOfdeletions
	print inputString

char[] foo(char str[])
{
  char* c = str;
  while(*c!='\0'){
    if(*c == ' '){
      *c++='\0';
      strcat(str, c);
    }
    c++;
  }
  return str;
}