子串替换

Question

I want to implement ac code such that it replaces only the exact matching not part of another string. check out my code.

#include <stdio.h>
#include <string.h>
int main ()
{
   char str[] ="This is a simpled simple string";
   char * pch;
   char str1[]= "simple";
   pch = strstr (str,str1);
   strncpy (pch,"sample",6);
   puts (str);
   return 0;
 }

the above code gives the output : This is sampled simple string

I want the output to be : This is simpled sample string

please help

Thanks.

Answer 1

The best way to deal with these types of question is consider each and every word one-by-one . And then check whether, the pattern (which we are looking for?) is present in the given string or not, if yes then replace it with replacing word .

Below is my code. (I know it may seem bit odd one out, but trust me it will work for any pattern-matching and replacement problem) . It will reduce and expand the final output according to the given pattern word and its corresponding replacement word.

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

int main() {
    /*    This program will replace the "demo" with "program"    */
    char input[] = "   isdemo Hello this is demo. replace demo with demoes something else demo";
    char pattern[] = "demo";
    char replace[] = "program";
    char output[105];
    int index = 0;

    /*Read the the input line word-by-word, 
      if the word == pattern[], then replace it else do nothing */
      for(int i=0; i<strlen(input);) {
          while(i<strlen(input) && !isalpha(input[i])) {
              output[index++] = input[i++];
          }

          char temp[105]; int j = 0;
          while(i<strlen(input) && isalpha(input[i])) {
              temp[j++] = input[i++];
          } 
          temp[j] = 0;

          if(strcmp(temp, pattern) == 0) {
             strncpy(output+index, replace, strlen(replace));
             index += strlen(replace);
          } else {
             strncpy(output+index, temp, strlen(temp));
             index += strlen(temp);
          }
      }

      output[index] = 0;
      puts(output);

    return 0;
}

If i'm still missing any test case. I will be pleased to know about it.

Answer 2

A word can start with space or may lie at the start of string and can end with a space, a full stop, a comma or with the end of string. using these conditions you can easily identify any word within a string. Following code describes it according to your example.

Using this code you can replace a word with another word of any size.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
int main()
{
    char str[] = "simple This is a simpled simple simple. simple, string simple";
    char * pch;
    char * result = str;
    char * temp;

    char str1[] = "simple"; //string to be replaced
    char str2[] = "sample"; //string to be replaced with

    pch = strstr(result, str1);
    while(pch)
    {
        temp = result;
        if ((pch == str || *(pch - 1) == ' ') && (strlen(pch) == strlen(str1) || !isalpha(*(pch + strlen(str1)))))
        {
            result = (char*)malloc(strlen(temp)+(strlen(str2) - strlen(str1))+1); //allocate new memory, +1 for trailing null character
            strncpy(result, temp, pch - temp); // copy previous string till found word to new allocated memory
            strncpy(result + (pch - temp), str2, strlen(str2)); // replace previous word with new word
            strncpy(result + (pch - temp) + strlen(str2), pch + strlen(str1), strlen(pch + strlen(str1))); // place previous string after replaced word
            strncpy(result + strlen(temp) + (strlen(str2) - strlen(str1)), "\0", 1); // place null character at the end of string
            if (temp != str)
                free(temp); // free extra memory
        }
        pch = strstr(result + (pch - temp) + 1, str1); // search for another word in new string after the last word was replaced
    }

    puts(result);
    if (result != str)
        free(result);
    return 0;
}

Answer 3

First, you need search the entire string continuously until no substring is found, second, you need check the char before and after the substring returned by strstr, to make sure that the found substring is a complete word. When check for word boundary, take special care when the word is at the beginning or end of the longer string. For example:

#include <stdio.h>
#include <string.h>
int main(void)
{
    char str[] ="simple simples is a simpled simple string simple";
    char *s = str;
    char *pch = str;
    char str1[]= "simple";
    int len = strlen(str1);
    int pos;
    while (1) {
        pch = strstr(s, str1);
        if (!pch)  // no more occurrences of str1, quit
            break;
        pos = pch - str;
        if (pos == 0) { // if it's the beginning
            if (!isalpha(pch[len])) {
                strncpy(pch, "sample", 6);
            }
        } else { // check two ends
            if (!isalpha(*(pch-1)) && !isalpha(*(pch+len))) {
                    strncpy(pch, "sample", 6);
            }
        }
        s = pch + len;
   }
   puts(str);
   return 0;
}

Answer 4

I updated my code.This deals with the replacement that you want.

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

void replace(char *buf, size_t bufSize, const char *word_to_replace, const char *replacement_word);

int main(void)
{
    char str[100] = "simple Asimple simpleB This is a simpled simple string and simple is good sometimes!, simple";
    replace(str, sizeof(str), "simple", "sample");
    printf("%s\n", str);
    return 0;
}

void replace(char *buf, size_t bufSize, const char *word_to_replace, const char *replacement_word)
{
    size_t buf_len = strlen(buf), word_len = strlen(word_to_replace);
    char *ptr = strstr(buf, word_to_replace);
    if (ptr == NULL) {
        fprintf(stderr, "Could not find matches.\n");
        return;
    }
    bool _G = 0;
    char *tmp = (char *)malloc(bufSize);

    // Deal with begining of line
    if (ptr == buf) {
        if (ptr[word_len] == ' ' || ptr[word_len] == '\0') {
            _G = 1;
        }
        if (_G) {
            strcpy_s(tmp, bufSize, ptr + word_len);
            *ptr = 0;
            strcat_s(buf, bufSize, replacement_word);
            strcat_s(buf, bufSize, tmp);
            _G = 0;
        }
    }
    else {
        if (*(ptr - 1) == ' ' && (ptr[word_len] == ' ' || ptr[word_len] == '\0')) {
            _G = 1;
        }
        if (_G) {
            strcpy_s(tmp, bufSize, ptr + word_len);
            *ptr = 0;
            strcat_s(buf, bufSize, replacement_word);
            strcat_s(buf, bufSize, tmp);
            _G = 0;
        }
    }
    // deal with the rest
    while (ptr = strstr(ptr + 1, word_to_replace))
    {
        if (*(ptr - 1) == ' ' && (ptr[word_len] == ' ' || ptr[word_len] == '\0')) {
            _G = 1;
        }
        if (_G) {
            strcpy_s(tmp, bufSize, ptr + word_len);
            *ptr = 0;
            strcat_s(buf, bufSize, replacement_word);
            strcat_s(buf, bufSize, tmp);
            _G = 0;
        }
    }
    free(tmp);
}