Open In App

# Remove characters from the first string which are present in the second string

Given two strings string1 and string2, remove those characters from the first string(string1) which are present in the second string(string2). Both strings are different and contain only lowercase characters.
NOTE: The size of the first string is always greater than the size of the second string( |string1| > |string2|).

Example:

Input:
string1 = “computer”
string2 = “cat”
Output: “ompuer”
Explanation: After removing characters(c, a, t)
from string1 we get “ompuer”.

Input:
string1 = “occurrence”
string2 = “car”
Output: “ouene”
Explanation: After removing characters
(c, a, r) from string1 we get “ouene”.

## We strongly recommend that you click here and practise it, before moving on to the solution.

Algorithm: Let the first input string be a ”test string” and the string which has characters to be removed from the first string be a “mask”

1. Initialize:  res_ind = 0 /* index to keep track of the processing of each character in i/p string */
ip_ind = 0 /* index to keep track of the processing of each character in the resultant string */
2. Construct count array from mask_str. The count array would be:
(We can use a Boolean array here instead of an int count array because we don’t need a count, we need to know only if the character is present in a mask string)
count[‘a’] = 1
count[‘k’] = 1
count[‘m’] = 1
count[‘s’] = 1
3. Process each character in the input string and if the count of that character is 0, then only add the character to the resultant string.
str = “tet tringng” // ’s’ has been removed because ’s’ was present in mask_str, but we have got two extra characters “ng”
ip_ind = 11
res_ind = 9
Put a ‘\0′ at the end of the string.

Implementations:

## C++

 `// C++ program to remove duplicates, the order of``// characters is not maintained in this progress``#include ``#define NO_OF_CHAR 256``using` `namespace` `std;` `int``* getcountarray(string str2)``{``    ``int``* count = (``int``*)``calloc``(``sizeof``(``int``), NO_OF_CHAR);` `    ``for` `(``int` `i = 0; i < str2.size(); i++)``    ``{``        ``count[str2[i]]++;``    ``}` `    ``return` `count;``}` `/* removeDirtyChars takes two``string as arguments: First``string (str1)  is the one from``where function removes dirty``characters. Second  string(str2)``is the string which contain``all dirty characters which need``to be removed  from first``string */``string removeDirtyChars(string str1, string str2)``{``    ``// str2 is the string``    ``// which is to be removed``    ``int``* count = getcountarray(str2);``    ``string res;``     ` `    ``// ip_idx helps to keep``    ``// track of the first string``    ``int` `ip_idx = 0;` `    ``while` `(ip_idx < str1.size())``    ``{``        ``char` `temp = str1[ip_idx];``        ``if` `(count[temp] == 0)``        ``{``            ``res.push_back(temp);``        ``}``        ``ip_idx++;``    ``}` `    ``return` `res;``}` `// Driver Code``int` `main()``{``    ``string str1 = ``"geeksforgeeks"``;``    ``string str2 = ``"mask"``;` `    ``// Function call``    ``cout << removeDirtyChars(str1, str2) << endl;``}`

## C

 `#include ``#include ``#define NO_OF_CHARS 256` `/* Returns an array of size 256 containing count``   ``of characters in the passed char array */``int``* getCharCountArray(``char``* str)``{``    ``int``* count = (``int``*)``calloc``(``sizeof``(``int``), NO_OF_CHARS);``    ``int` `i;``    ``for` `(i = 0; *(str + i); i++)``        ``count[*(str + i)]++;``    ``return` `count;``}` `/* removeDirtyChars takes two``string as arguments: First``string (str)  is the one from``where function removes dirty``characters. Second  string is``the string which contain all``dirty characters which need to``be removed  from first string``*/``char``* removeDirtyChars(``char``* str, ``char``* mask_str)``{``    ``int``* count = getCharCountArray(mask_str);``    ``int` `ip_ind = 0, res_ind = 0;``    ``while` `(*(str + ip_ind))``    ``{``        ``char` `temp = *(str + ip_ind);``        ``if` `(count[temp] == 0)``        ``{``            ``*(str + res_ind) = *(str + ip_ind);``            ``res_ind++;``        ``}``        ``ip_ind++;``    ``}` `    ``/* After above step string is ngring.``      ``Removing extra "iittg" after string*/``    ``*(str + res_ind) = ``'\0'``;` `    ``return` `str;``}` `/* Driver code*/``int` `main()``{``    ``char` `str[] = ``"geeksforgeeks"``;``    ``char` `mask_str[] = ``"mask"``;``    ``printf``(``"%s"``, removeDirtyChars(str, mask_str));``    ``return` `0;``}`

## Java

 `// Java program to remove duplicates, the order of``// characters is not maintained in this program` `public` `class` `GFG {``    ``static` `final` `int` `NO_OF_CHARS = ``256``;` `    ``/* Returns an array of size 256 containing count``       ``of characters in the passed char array */``    ``static` `int``[] getCharCountArray(String str)``    ``{``        ``int` `count[] = ``new` `int``[NO_OF_CHARS];``        ``for` `(``int` `i = ``0``; i < str.length(); i++)``            ``count[str.charAt(i)]++;` `        ``return` `count;``    ``}` `    ``/* removeDirtyChars takes two``    ``string as arguments: First``    ``string (str)  is the one from``    ``where function removes``    ``dirty characters. Second ``    ``string is the string which``    ``contain all dirty characters``    ``which need to be removed``    ``from first string */``    ``static` `String removeDirtyChars(String str,``                                   ``String mask_str)``    ``{``        ``int` `count[] = getCharCountArray(mask_str);``        ``int` `ip_ind = ``0``, res_ind = ``0``;` `        ``char` `arr[] = str.toCharArray();` `        ``while` `(ip_ind != arr.length)``        ``{``            ``char` `temp = arr[ip_ind];``            ``if` `(count[temp] == ``0``) {``                ``arr[res_ind] = arr[ip_ind];``                ``res_ind++;``            ``}``            ``ip_ind++;``        ``}` `        ``str = ``new` `String(arr);` `        ``/* After above step string is ngring.``        ``Removing extra "iittg" after string*/` `        ``return` `str.substring(``0``, res_ind);``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``String str = ``"geeksforgeeks"``;``        ``String mask_str = ``"mask"``;``        ``System.out.println(removeDirtyChars(str, mask_str));``    ``}``}`

## Python3

 `# Python program to remove characters``# from first string which``# are present in the second string``NO_OF_CHARS ``=` `256` `# Utility function to convert``# from string to list`  `def` `toList(string):``    ``temp ``=` `[]``    ``for` `x ``in` `string:``        ``temp.append(x)``    ``return` `temp` `# Utility function to``# convert from list to string`  `def` `toString(``List``):``    ``return` `''.join(``List``)` `# Returns an array of size``# 256 containing count of characters``# in the passed char array`  `def` `getCharCountArray(string):``    ``count ``=` `[``0``] ``*` `NO_OF_CHARS``    ``for` `i ``in` `string:``        ``count[``ord``(i)] ``+``=` `1``    ``return` `count` `# removeDirtyChars takes two``# string as arguments: First``# string (str)  is the one``# from where function removes dirty``# characters. Second  string``# is the string which contain all``# dirty characters which need``# to be removed  from first string`  `def` `removeDirtyChars(string, mask_string):``    ``count ``=` `getCharCountArray(mask_string)``    ``ip_ind ``=` `0``    ``res_ind ``=` `0``    ``temp ``=` `''``    ``str_list ``=` `toList(string)` `    ``while` `ip_ind !``=` `len``(str_list):``        ``temp ``=` `str_list[ip_ind]``        ``if` `count[``ord``(temp)] ``=``=` `0``:``            ``str_list[res_ind] ``=` `str_list[ip_ind]``            ``res_ind ``+``=` `1``        ``ip_ind ``+``=` `1` `    ``# After above step string is ngring.``     ``# Removing extra "iittg" after string``    ``return` `toString(str_list[``0``:res_ind])`  `# Driver code``mask_string ``=` `"mask"``string ``=` `"geeksforgeeks"``print``(removeDirtyChars(string, mask_string))` `# This code is contributed by Bhavya Jain`

## C#

 `// C# program to remove``// duplicates, the order``// of characters is not``// maintained in this program``using` `System;``class` `GFG {``    ``static` `int` `NO_OF_CHARS = 256;` `    ``/* Returns an array of size``    ``256 containing count of``    ``characters in the passed``    ``char array */``    ``static` `int``[] getCharCountArray(String str)``    ``{``        ``int``[] count = ``new` `int``[NO_OF_CHARS];``        ``for` `(``int` `i = 0; i < str.Length; i++)``            ``count[str[i]]++;` `        ``return` `count;``    ``}` `    ``/* removeDirtyChars takes two``    ``string as arguments: First``    ``string (str) is the one from``    ``where function removes dirty``    ``characters. Second string is``    ``the string which contain all``    ``dirty characters which need``    ``to be removed from first string */``    ``static` `String removeDirtyChars(String str,``                                   ``String mask_str)``    ``{``        ``int``[] count = getCharCountArray(mask_str);``        ``int` `ip_ind = 0, res_ind = 0;` `        ``char``[] arr = str.ToCharArray();` `        ``while` `(ip_ind != arr.Length)``        ``{``            ``char` `temp = arr[ip_ind];``            ``if` `(count[temp] == 0) {``                ``arr[res_ind] = arr[ip_ind];``                ``res_ind++;``            ``}``            ``ip_ind++;``        ``}` `        ``str = ``new` `String(arr);` `        ``/* After above step string``        ``is ngring. Removing extra``        ``"iittg" after string*/``        ``return` `str.Substring(0, res_ind);``    ``}` `    ``// Driver Code``    ``public` `static` `void` `Main()``    ``{``        ``String str = ``"geeksforgeeks"``;``        ``String mask_str = ``"mask"``;``        ``Console.WriteLine(removeDirtyChars(str, mask_str));``    ``}``}` `// This code is contributed by mits`

## Javascript

 ``

Output

```geeforgee
```

Time Complexity: O(m+n) Where m is the length of the mask string and n is the length of the input string.
Auxiliary Space: O(m)

An efficient solution is we find every character of string2 in string1 if that character is present then we simply erase that character from string1.

## C++

 `// C++ program to remove duplicates``#include ``using` `namespace` `std;` `string removeChars(string string1, string string2) {``       ``//we extract every character of string string 2``         ``for``(``auto` `i:string2)``        ``{``           ``//we find char exit or not``           ``while``(find(string1.begin(),string1.end(),i)!=string1.end())``            ``{``                ``auto` `itr = find(string1.begin(),string1.end(),i);``               ``//if char exit we simply remove that char``                ``string1.erase(itr);``            ``}``        ``}``        ``return` `string1;``    ``}``// Driver Code``int` `main()``{``        ``string string1,string2;``        ``string1=``"geeksforgeeks"``;``        ``string2=``"mask"``;``         ``cout<<  removeChars(string1,string2)<

## C

 `#include ``#include ` `char``* removeChars(``char` `string1[], ``char` `string2[]) {``    ``int` `i, j, k;``    ``int` `len1 = ``strlen``(string1);``    ``int` `len2 = ``strlen``(string2);` `    ``for` `(i = 0; i < len2; i++) {``        ``for` `(j = 0; j < len1; j++) {``            ``if` `(string1[j] == string2[i]) {``                ``for` `(k = j; k < len1; k++) {``                    ``string1[k] = string1[k + 1];``                ``}``                ``len1--;``                ``j--;``            ``}``        ``}``    ``}` `    ``return` `string1;``}` `int` `main() {``    ``char` `string1[] = ``"geeksforgeeks"``;``    ``char` `string2[] = ``"mask"``;``    ``printf``(``"%s\n"``, removeChars(string1, string2));``    ``return` `0;``}`

## Java

 `/*package whatever //do not write package name here */` `import` `java.io.*;` `class` `GFG {``    ``public` `static` `String removeChars(String string1,``                                     ``String string2)``    ``{``        ``// we extract every character of string string 2``        ``for` `(``int` `index = ``0``; index < string2.length();``             ``index++) {``            ``char` `i = string2.charAt(index);``            ``// we find char exit or not``            ``while` `(string1.contains(i + ``""``)) {``                ``int` `itr = string1.indexOf(i);``                ``// if char exit we simply remove that char``                ``string1 = string1.replace((i + ``""``), ``""``);``            ``}``        ``}``        ``return` `string1;``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``String string1, string2;``        ``string1 = ``"geeksforgeeks"``;``        ``string2 = ``"mask"``;``        ``System.out.println(removeChars(string1, string2));``    ``}``}``//This code is contributed by KaaL-EL.`

## Python3

 `# Python 3 program to remove duplicates``def` `removeChars(string1, string2):` `       ``# we extract every character of string string 2``    ``for` `i ``in` `string2:` `        ``# we find char exit or not``        ``while` `i ``in` `string1:` `            ``itr ``=` `string1.find(i)``           ``# if char exit we simply remove that char``            ``string1 ``=` `string1.replace(i, '')` `    ``return` `string1` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:` `    ``string1 ``=` `"geeksforgeeks"``    ``string2 ``=` `"mask"``    ``print``(removeChars(string1, string2))` `    ``# This code is contributed by ukasp.`

## C#

 `// Include namespace system``using` `System;``public` `class` `GFG``{``  ``public` `static` `String removeChars(String string1, String string2)``  ``{` `    ``// we extract every character of string string 2``    ``for` `(``int` `index = 0; index < string2.Length; index++)``    ``{``      ``var` `i = string2[index];` `      ``// we find char exit or not``      ``while` `(string1.Contains(i.ToString() + ``""``))``      ``{` `        ``// if char exit we simply remove that char``        ``string1 = string1.Replace((i.ToString() + ``""``),``""``);``      ``}``    ``}``    ``return` `string1;``  ``}` `  ``// Driver Code``  ``public` `static` `void` `Main(String[] args)``  ``{``    ``String string1;``    ``String string2;``    ``string1 = ``"geeksforgeeks"``;``    ``string2 = ``"mask"``;``    ``Console.WriteLine(GFG.removeChars(string1, string2));``  ``}``}` `// This code is contributed by aadityaburujwale.`

## Javascript

 `// function to remove characters from string1 that are present in string2``function` `removeChars(string1, string2) {``    ``let i, j, k;``    ``let len1 = string1.length; ``// get length of string1``    ``let len2 = string2.length; ``// get length of string2` `    ``// loop over characters in string2``    ``for` `(i = 0; i < len2; i++) {``        ``// loop over characters in string1``        ``for` `(j = 0; j < len1; j++) {``            ``// if character is found in both strings``            ``if` `(string1.charAt(j) == string2.charAt(i)) {``                ``// remove character from string1``                ``string1 = string1.substring(0, j) + string1.substring(j + 1);``                ``len1--; ``// decrease length of string1``                ``j--; ``// decrement j to account for shifted indices``            ``}``        ``}``    ``}` `    ``return` `string1;``}` `let string1 = ``"geeksforgeeks"``;``let string2 = ``"mask"``;``console.log(removeChars(string1, string2));`

Output

```geeforgee
```

Time Complexity: O(n*m), where n is the size of given string2 and m is the size of string1.
Auxiliary Space: O(1), as no extra space is used

Efficient Solution: An efficient solution is that we can mark the occurrence of all characters present in second string by -1 in frequency character array and then while traversing first string we can ignore the marked characters as shown in below program.

## C++

 `// C++ program to remove duplicates``#include ``using` `namespace` `std;` `char``* removeChars(``char``* s1, ``int` `n1, ``char``* s2, ``int` `n2)``{``    ``int` `arr[26] = { 0 }; ``// an array of size 26 to count the frequency of characters``    ``int` `curr = 0; ``    ``for` `(``int` `i = 0; i < n2; i++) ``// assigned all the index of characters which are present ``        ``arr[s2[i] - ``'a'``] = -1;   ``// in second string by -1 (just flagging)``    ``for` `(``int` `i = 0; i < n1; i++) ``        ``if` `(arr[s1[i] - ``'a'``] != -1) {  ``// Checking if the index of characters don't have -1``            ``s1[curr] = s1[i];       ``// i.e, that character was not present in second string``            ``curr++;               ``// and then storing that character in string``        ``}``    ``s1[curr] = ``'\0'``;    ``// marking last character as null to point the end of string``    ``return` `s1;``}` `// driver code``int` `main()``{``    ``char` `string1[] = ``"geeksforgeeks"``;``    ``char` `string2[] = ``"mask"``;``    ``int` `n1 = ``sizeof``(string1) / ``sizeof``(string1[0]);``    ``int` `n2 = ``sizeof``(string2) / ``sizeof``(string2[0]);``    ``cout << removeChars(string1, n1, string2, n2) << endl;``    ``return` `0;``}`

## C

 `// C program to remove duplicates``#include ``#include ` `char``* removeChars(``char``* s1, ``int` `n1, ``char``* s2, ``int` `n2)``{``    ``int` `arr[26] = { 0 }; ``// an array of size 26 to count the``                         ``// frequency of characters``    ``int` `curr = 0;``    ``for` `(``int` `i = 0; i < n2;``         ``i++) ``// assigned all the index of characters which``              ``// are present``        ``arr[s2[i] - ``'a'``]``            ``= -1; ``// in second string by -1 (just flagging)``    ``for` `(``int` `i = 0; i < n1; i++)``        ``if` `(arr[s1[i] - ``'a'``]``            ``!= -1) { ``// Checking if the index of characters``                     ``// don't have -1``            ``s1[curr] = s1[i]; ``// i.e, that character was not``                              ``// present in second string``            ``curr++; ``// and then storing that character in``                    ``// string``        ``}``    ``s1[curr] = ``'\0'``; ``// marking last character as null to``                     ``// point the end of string``    ``return` `s1;``}` `// driver code``int` `main()``{``    ``char` `string1[] = ``"geeksforgeeks"``;``    ``char` `string2[] = ``"mask"``;``    ``int` `n1 = ``strlen``(string1);``    ``int` `n2 = ``strlen``(string2);``    ``printf``(``"%s\n"``, removeChars(string1, n1, string2, n2));``    ``return` `0;``}` `//contributed by SATYAM NAYAK`

## Java

 `import` `java.util.*;``public` `class` `GFG {``    ``static` `String removeChars(String s1, ``int` `n1, String s2,``                              ``int` `n2)``    ``{``        ``String s3 = ``""``;` `        ``// an array of size 26 to count the frequency of``        ``// characters``        ``int``[] arr = ``new` `int``[``26``];``        ``for` `(``int` `i = ``0``; i < ``26``; i++) {``            ``arr[i] = ``0``;``        ``}``        ``for` `(``int` `i = ``0``; i < n2;``             ``i++) ``// assigned all the index of characters``            ``// which are present``            ``arr[s2.charAt(i) - ``'a'``]``                ``= -``1``; ``// in second string by -1``        ``// (just flagging)``        ``for` `(``int` `i = ``0``; i < n1; i++) {``            ``if` `(arr[s1.charAt(i) - ``'a'``] != -``1``) {``                ``// Checking if the index of``                ``// characters don't have -1``                ``s3 += s1.charAt(``                    ``i); ``// i.e, that character was not``                ``// present in second string and``                ``// then storing that character``                ``// in string``            ``}``        ``}` `        ``s1 = s3;``        ``return` `s1;``    ``}``    ``// driver code``    ``public` `static` `void` `main(String args[])``    ``{``        ``String string1 = ``"geeksforgeeks"``;``        ``String string2 = ``"mask"``;` `        ``int` `n1 = string1.length();``        ``int` `n2 = string2.length();``        ``System.out.println(``            ``removeChars(string1, n1, string2, n2));``    ``}``}``// This code is contributed by Samim Hossain``// Mondal.`

## Python3

 `# Python3 program to remove duplicates``def` `removeChars(s1, n1, s2, n2):``    ``s3 ``=` `""` `    ``# an array of size 26 to count the frequency of``    ``# characters``    ``arr ``=` `[``0``] ``*` `26` `    ``for` `i ``in` `range``(``0``, n2):``        ``# assigned all the index of characters``        ``# which are present``        ``arr[``ord``(s2[i]) ``-` `ord``(``'a'``)] ``=` `-``1`  `# in second string by -1``    ``# (just flagging)``    ``for` `i ``in` `range``(``0``, n1):``        ``if` `(arr[``ord``(s1[i]) ``-` `ord``(``'a'``)] !``=` `-``1``):``            ``# Checking if the index of``            ``# characters don't have -1``            ``s3 ``+``=` `s1[i]  ``# i.e, that character was not``            ``# present in second string and``            ``# then storing that character``            ``# in string` `    ``s1 ``=` `s3``    ``return` `s1`  `# driver code``string1 ``=` `"geeksforgeeks"``string2 ``=` `"mask"``n1 ``=` `len``(string1)``n2 ``=` `len``(string2)``print``(removeChars(string1, n1, string2, n2))` `# contributed by akashish__`

## C#

 `// C# program to remove duplicates``using` `System;` `class` `GFG {``  ``static` `string` `removeChars(``string` `s1, ``int` `n1, ``string` `s2,``                            ``int` `n2)``  ``{``    ``string` `s3 = ``""``;` `    ``// an array of size 26 to count the frequency of``    ``// characters``    ``int``[] arr = ``new` `int``[26];``    ``for` `(``int` `i = 0; i < 26; i++) {``      ``arr[i] = 0;``    ``}``    ``for` `(``int` `i = 0; i < n2;``         ``i++) ``// assigned all the index of characters``      ``// which are present``      ``arr[s2[i] - ``'a'``] = -1; ``// in second string by -1``    ``// (just flagging)``    ``for` `(``int` `i = 0; i < n1; i++) {``      ``if` `(arr[s1[i] - ``'a'``]``          ``!= -1)``      ``{``        ``// Checking if the index of``        ``// characters don't have -1``        ``s3 += s1[i]; ``// i.e, that character was not``        ``// present in second string and``        ``// then storing that character``        ``// in string``      ``}``    ``}` `    ``s1 = s3;``    ``return` `s1;``  ``}` `  ``// driver code``  ``public` `static` `void` `Main()``  ``{``    ``string` `string1 = ``"geeksforgeeks"``;``    ``string` `string2 = ``"mask"``;``    ``int` `n1 = string1.Length;``    ``int` `n2 = string2.Length;``    ``Console.WriteLine(``      ``removeChars(string1, n1, string2, n2));``  ``}``}` `// This code is contributed by Samim Hossain Mondal.`

## Javascript

 `function` `removeChars(s1, n1, s2, n2) {``    ``let arr = ``new` `Array(26).fill(0); ``// an array of size 26 to count the frequency of characters``    ``let curr = 0;``    ``for` `(let i = 0; i < n2; i++) { ``// assigned all the index of characters which are present in second string by -1 (just flagging)``        ``arr[s2.charCodeAt(i) - ``'a'``.charCodeAt(0)] = -1;``    ``}``    ``let output = ``''``;``    ``for` `(let i = 0; i < n1; i++) {``        ``if` `(arr[s1.charCodeAt(i) - ``'a'``.charCodeAt(0)] != -1) { ``// Checking if the index of characters don't have -1``            ``output += s1.charAt(i); ``// i.e, that character was not present in second string``        ``}``    ``}``    ``return` `output;``}` `let string1 = ``"geeksforgeeks"``;``let string2 = ``"mask"``;``let n1 = string1.length;``let n2 = string2.length;``console.log(removeChars(string1, n1, string2, n2));`

Output

```geeforgee
```

Time Complexity: O(|S1|), where |S1| is the size of given string 1.
Auxiliary Space: O(1), as only an array of constant size (26) is used.