# In-place replace multiple occurrences of a pattern

Given a string and a pattern, replace multiple occurrences of a pattern by character ‘X’. The conversion should be in-place and solution should replace multiple consecutive (and non-overlapping) occurrences of a pattern by a single ‘X’.

```String – GeeksForGeeks
Pattern – Geeks
Output: XforX

String – GeeksGeeks
Pattern – Geeks
Output: X

String – aaaa
Pattern – aa
Output: X

String – aaaaa
Pattern – aa
Output: Xa
```

## Recommended: Please solve it on “PRACTICE ” first, before moving on to the solution.

The idea is to maintain two index i and j for in-place replacement. Index i always points to next character in the output string. Index j traverses the string and searches for one or more pattern match. If a match is found, we put character ‘X’ at index i and increment index i by 1 and index j by length of the pattern. Index i is increment only once if we find multiple consecutive occurrences of the pattern. If the pattern is not found, we copy current character at index j to index i and increment both i and j by 1. Since pattern length is always more than equal to 1 and replacement is only 1 character long, we would never overwrite unprocessed characters i.e j >= i is invariant.

 `// C++ program to in-place replace multiple ` `// occurrences of a pattern by character ‘X’ ` `#include ` `using` `namespace` `std; ` ` `  `// returns true if pattern is prefix of str ` `bool` `compare(``char``* str, ``char``* pattern) ` `{ ` `    ``for` `(``int` `i = 0; pattern[i]; i++) ` `        ``if` `(str[i] != pattern[i]) ` `            ``return` `false``; ` `    ``return` `true``; ` `} ` ` `  `// Function to in-place replace multiple ` `// occurrences of a pattern by character ‘X’ ` `void` `replacePattern(``char``* str, ``char``* pattern) ` `{ ` `    ``// If pattern is null or empty string, ` `    ``// nothing needs to be done ` `    ``if` `(pattern == NULL) ` `        ``return``; ` ` `  `    ``int` `len = ``strlen``(pattern); ` `    ``if` `(len == 0) ` `        ``return``; ` ` `  `    ``int` `i = 0, j = 0; ` `    ``int` `count; ` ` `  `    ``// for each character ` `    ``while` `(str[j]) { ` `        ``count = 0; ` ` `  `        ``// compare str[j..j+len] with pattern ` `        ``while` `(compare(str + j, pattern)) { ` `            ``// increment j by length of pattern ` `            ``j = j + len; ` `            ``count++; ` `        ``} ` ` `  `        ``// If single or multiple occurrences of pattern ` `        ``// is found, replace it by character 'X' ` `        ``if` `(count > 0) ` `            ``str[i++] = ``'X'``; ` ` `  `        ``// copy character at current position j ` `        ``// to position i and increment i and j ` `        ``if` `(str[j]) ` `            ``str[i++] = str[j++]; ` `    ``} ` ` `  `    ``// add a null character to terminate string ` `    ``str[i] = ``'\0'``; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``char` `str[] = ``"GeeksforGeeks"``; ` `    ``char` `pattern[] = ``"Geeks"``; ` ` `  `    ``replacePattern(str, pattern); ` `    ``cout << str; ` ` `  `    ``return` `0; ` `} `

Output:

```XforX
```

The time complexity of above algorithm is O(n*m), where n is length of string and m is length of the pattern.

Implementation using STL

```
The idea of this implementation is to use the STL in-built functions
to search for pattern string in main string and then erasing it
from the main string
```

 `// C++ program to in-place replace multiple ` `// occurrences of a pattern by character ‘X’ ` `#include ` `using` `namespace` `std; ` ` `  `// Function to in-place replace multiple ` `// occurrences of a pattern by character ‘X’ ` `void` `replacePattern(string str, string pattern) ` `{ ` ` `  `    ``// making an iterator for string str ` `    ``string::iterator it = str.begin(); ` `    ``// run this loop until iterator reaches end of string ` `    ``while` `(it != str.end()) { ` `        ``// searching the first index in string str where ` `        ``// the first occurrence of string pattern occurs ` `        ``it = search(str.begin(), str.end(), pattern.begin(), pattern.end()); ` `        ``// checking if iterator is not pointing to end of the ` `        ``// string str ` `        ``if` `(it != str.end()) { ` `            ``// erasing the full pattern string from that iterator ` `            ``// position in string str ` `            ``str.erase(it, it + pattern.size()); ` `            ``// inserting 'X' at that iterator posiion ` `            ``str.insert(it, ``'X'``); ` `        ``} ` `    ``} ` ` `  `    ``// this loop removes consecutive 'X' in string s ` `    ``// Example: GeeksGeeksforGeeks was changed to 'XXforX' ` `    ``// running this loop will change it to 'XforX' ` `    ``for` `(``int` `i = 0; i < str.size() - 1; i++) { ` `        ``if` `(str[i] == ``'X'` `&& str[i + 1] == ``'X'``) { ` `            ``// removing 'X' at posiion i in string str ` `            ``str.erase(str.begin() + i); ` `            ``i--; ``// i-- because one character was deleted ` `            ``// so repositioning i ` `        ``} ` `    ``} ` `    ``cout << str; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``string str = ``"GeeksforGeeks"``; ` `    ``string pattern = ``"Geeks"``; ` ` `  `    ``replacePattern(str, pattern); ` ` `  `    ``return` `0; ` `} `

Output:

```XforX
```