Supprimer un caractère et le déplacer dans une chaîne

Cela peut être fait de plusieurs manières. Ce que je pense en ce moment, c'est de stocker le tableau not Allowed char qui va filtrer quel caractère doit afficher ou non. Quelque chose comme suivant ..

#include <stdio.h>
#include <string.h>

// Global Scope variable declaration
int notAllowedChar[128] = {0}; // 0 for allowed , 1 for not allowed
char inputString[100];


void recursion(int pos, int len) {

    if( pos >= len ) {
       printf("\n"); // new line
       return;
    }

    if( notAllowedChar[inputString[pos]]) {// not printing
       recursion( pos + 1 , len );
    }
    else {
       printf("%c", inputString[pos]);
       recursion( pos + 1 , len );
    }

}

int main() {

 gets(inputString);  // taking input String

    printf("Enter not allowed chars:: "); // here we can even run a loop for all of them
    char notAllowed;
    scanf("%c", &notAllowed);
    notAllowedChar[notAllowed] = 1;
    int len = strlen(inputString);
    recursion( 0 , len );

}

Comment ça marche

Disons que nous avons une simple chaîne "Hello world" et nous voulons que l soit supprimé de la chaîne finale, donc la sortie finale sera "Heo word"

Ici, la longueur de "Hello world" est de 11 caractères avant d'appeler la fonction de récursivité, nous nous assurons que l'index 'l' qui est de 108 valeurs ascii lien 1 dans tableau notAllowedChar .

maintenant nous appelons la méthode de récursivité avec la valeur (0, 11), Dans la méthode de récursion, nous avons principalement 2 opérations if logiques, la première est pour le cas de base où nous allons terminer notre appel de récursivité lorsque pos est égal ou supérieur à 11. et si ce n'est pas vrai, nous ferons la deuxième opération logique si current char est imprimable ou non. Il s'agit simplement de vérifier où se trouve ce caractère dans la liste notAllowedChar ou non. Chaque fois que nous augmentons la valeur de pos + 1 et faisons un appel de récursivité, et enfin lorsque pos est égal ou supérieur à 11, ce qui signifie que nous avons pris toute notre décision concernant l'impression de char ou pas notre récursion prendra fin. J'ai essayé d'assigner une variable avec un nom significatif. Si vous ne comprenez toujours pas comment cela fonctionne, vous devez utiliser une simple simulation de récursivité basique (recherche sur youtube) et vous devez également essayer de déboguer manuellement la façon dont la valeur change dans portée locale de récursivité . Cela peut prendre du temps mais il vaut la peine de le comprendre. Tout le meilleur.

#include <stdio.h>

void RemoveChar(char* str, char chr) {
char *str_old = str;
char *str_new = str;

while (*str_old)
{
    *str_new = *str_old++;
    str_new += (*str_new != chr);
}

*str_new = '\0'; }

int main() {
char string[] = "the weather is cloudy";

RemoveChar(string, 'e');

printf("'%s'\n", string);

return 0; }

Un moyen simple de le faire est de boucler sur la chaîne et d'ajouter toute lettre qui ne correspond pas à la lettre indésirable.

Voici une démonstration:

char *source = "the weather is cloudy";
int source_len = strlen(source);

char *target = (char *)calloc(source_len, sizeof(char));
int target_len = 0;

char to_remove = 'e';

for(int i = 0; i < source_len; i++)
{
    if(source[i] != to_remove)
    {
        target[target_len++] = source[i];
    }
}

puts(target); // Output "th wathr is cloudy" in the console

p >

#include <stdio.h>

void remove_impl(char* s, char c, char* d) {
    if (*s != c) {
        *d++ = *s;
    }
    if (*s != '\0') {
        remove_impl(++s, c, d);
    }
}

void remove(char* s, char c) {
    remove_impl(s, c, s);
}

int main() {
    char s[] = "the weather is cloudy";
    remove(s, 'e');
    puts(s);
}
How it works? Consider remove_impl. s is the original string, c is the character to be deleted from s, d is the resulting string, into which the characters of s, not equal to c, are written. Recursively iterates through the characters of s. If the next character is not equal to c, then it is written in d. The recursion stop point is the condition of checking that the end of s is reached. Since it is necessary to modify the source string, the wrapper is implemented (remove) in which as d, the original string (s) is passed.

char *remove_char(char *str, int c)
{
    char *pos = str;
    char *wrk = str;
    while(*wrk)
    {
        if(*wrk == c)
        {
            *wrk++;
            continue;
        }
        *pos++ = *wrk++;
    }
    *pos = 0;
    return str;
}

À mon tour de faire une proposition! J'ajoute un test d'assert et j'utilise les fonctions existantes (strchr et strcpy).

#include <string.h>
#include <stdio.h>
#include <assert.h>

int removeChar(char *str, char chr)
{
    assert(str != 0);                   // Always control entry !
    char *str_pnt = strchr(str, chr);   

    if (str_pnt) {
        strcpy(str_pnt, str_pnt+1); 
        removeChar(str_pnt, chr);
    }
}

void main (void)
{
    char str[] = "the weather is cloudy";
    char char_to_delete = 'e';

    removeChar(str, char_to_delete);
    puts(str);
}

#include <stdio.h>

/**
* Returns the number of removed chars.
* Base case: if the current char is the null char (end of the string)
* If the char should be deleted return 1 + no of chars removed in the remaining string.
* If it's a some other char simply return the number of chars removed in the remaining string
*/
int  removeCAfterwardsAndCount(char* s,char c){
  if((*s) == '\0'){
      return 0;
  }

  if((*s) == c){
     int noOfChars = removeCAfterwardsAndCount(s+1,c);// s+1 means the remaining string
      s[noOfChars] = *s; // move the current char (*s) noOfChars locations ahead

    return  noOfChars +1; // means this char is removed... some other char should be copied here...

  }
  else{
      int noOfChars  = removeCAfterwardsAndCount(s+1,c);
      s[noOfChars ] = *s;
    return  noOfChars ; // means this char is intact ... 
  }

}

int main()
{

    char s[] = "Arifullah Jan";
    printf("\n%s",s);
    int totalRemoved = removeCAfterwardsAndCount(s,'a');
    char *newS = &s[totalRemoved]; // the start of the string should now be originalPointer + total Number of chars removed

    printf("\n%s",newS);

    return 0;
}
Test Code HereTo avoid moving the chars using loops. I am just moving the chars forward which creates empty space in the start of the string. newS pointer is just a new pointer of the same string to eliminate the empty/garbage string.