Remove duplicates chars recursively - c

Question

I'm trying to write a recursive function which remove all duplicate chars from a given string recursively.
For example "Hello world" -> "Helo wrd".
The limitations I have are:
No loops allowed.
No more arguments can be added to the original function (remove_duplicates).
No functions from string.h library allowed, although I'm allowed to write them recursively.
I'm allowed to use another auxiliary recursive functions.
The function I wrote so far works only for short strings, it calls the function too many times. Any recommendations how to make it more efficient?
void remove_duplicates3(char string[], int index)//(str,RecursiveStrlen(str, 0)-1)
{
int length = RecursiveStrlen(string + 1, 0);
if (string[index] == '\0' || index == 0)
{
return;
}
if (string[0] != string[index])
{
remove_duplicates3(string, index - 1);
}
else
{
BackspaceString(string, index);
remove_duplicates3(string, length - 1);
}
remove_duplicates3(string + 1, length - 1);
}
int RecursiveStrlen(char str[], int index)
{
if (str[index] == '\0')
return index;
return RecursiveStrlen(str, index + 1);
}
void BackspaceString(char string[],int index)//deletes one char from string in a specific index
{
if (string[index] == '\0')//end of string
return;
string[index] = string[index + 1];
BackspaceString(string, index + 1);
}

Answer 1

Pure recursive solution:
void remove_char(char string[], char c, int read_index, int write_index) {
if (string[read_index] == 0) {
string[write_index] = 0;
return;
}
if (c == string[read_index]) {
remove_char(string, c, read_index + 1, write_index);
} else {
string[write_index] = string[read_index];
remove_char(string, c, read_index + 1, write_index + 1);
}
}
void remove_duplicates(char string[], int index) {
if (string[index] != 0 && string[index + 1] != 0) {
remove_char(string, string[index], index + 1, index + 1);
remove_duplicates(string, index + 1);
}
}

Answer 2

If you can use a global variable to store the resultant string, you could do this:
char result[30]="";
char over[30]="";
int check(char *over, char c)
{
if(*over != '\0')
{
if(*over == c)
{
return 1; //exists
}
else
{
return check(over+1, c);
}
}
return 0; //doesn't exist
}
int strLen(char *str)
{
if(*str=='\0')
{
return 0;
}
return strLen(str+1)+1;
}
void remove_duplicates(char *str)
{
if(*str != '\0')
{
if(check(over, *str)==0)
{
int len=strLen(result);
result[len++]=*str;
result[len]='\0';
len=strLen(over);
over[len++]=*str;
over[len]='\0';
}
remove_duplicates(str+1);
}
}
The resultant string is stored in result and over is a string which will store the already encountered characters as a string. over is checked by the check() function against a character c to return 0 if c was not found in over.
check() checks the value of over to determine if its argument c is present in over.
remove_duplicates() will check each character in the input string str. If the character was not encountered before in str, it is added to the list of already encountered characters to over and also appended to the result string.
This goes on till the input string str is over.

Answer 3

If your string is having only ASCII characters -
int arr[256] = {0};
/*
* str - Input string
* presult - Pointer to the buffer contain result
*/
void remove_duplicates(char *str, char *presult)
{
if(*str != '\0')
{
if(arr[*str] == 0)
{
*presult = *str;
arr[*str] = 1;
remove_duplicates(str+1, presult+1);
}
remove_duplicates(str+1, presult);
}
}

Answer 4

Simple Recursive Solution
I originally wrote this function in Scheme, but have translated it into C for you.
/*
* #params
* src -> input string from which to remove duplicates
* dest -> output string (initially empty)
* iter -> elements visited (initially 0)
*/
void remove_Dups_recursively(char *src, char *dest, int iter){
if(strlen(src) <= 1){
dest = src;
return;
}
if(iter == strlen(src)){
return;
}
if(strchr(dest, src[iter]) == NULL){
dest[strlen(dest)] = src[iter];
iter++;
remov(src, dest, iter);
}
else{
iter++;
remov(src, dest, iter);
}
}