# Check if String T can be made Substring of S by replacing given characters

• Last Updated : 14 Jan, 2023

Given two strings S and T and a 2D array replace[][], where replace[i] = {oldChar, newChar} represents that the character oldChar of T is replaced with newChar. The task is to find if it is possible to make string T a substring of S by replacing characters according to the replace array.

Note: Each character in T cannot be replaced more than once.

Example:

Input: S = “hoog3e7bar”, T = “geek”, replace = {{‘e’, ‘3’}, {‘t’, ‘7’}, {‘k’, ‘8’}}
Output: true
Explanation: Replace the first ‘e’ in T with ‘3’ and ‘k’ in T with ‘7’.
Now T = “g3e7” is a substring of S, so we return true.

Input: S = “gooleetbar”, T = “g00l”, replace = {{‘o’, ‘0’}}
Output: false

Approach: The problem can be solved using Hashing based on the following idea:

Keep a datastructure for storing all the mapping of replace array. Enumerate all substrings of S with the same length as T, and compare each substring to S for equality.

Follow the steps below to implement the above approach:

• Initialize a map say unmap, for mapping all the characters that oldChar can replace with newChar.
• Iterate over the replace array and do the mapping.
• Iterate over all the subarray of S of length equals to given string T.
• Check if the character in S is not equal to the character in T.
• If not equal then check if there exists any replacement of T[j] in unmap.
• If a mapping exists then continue.
• Otherwise, break from the current iteration and look for the other substring.
• If we successfully find a valid substring, then return true.
• Otherwise, return false.

Below is the implementation of the above approach.

## C++

 `// C++ code to implement the approach` `#include ``using` `namespace` `std;` `// Function to check if the string``// can be made substring of S``bool` `match(string S, string T,``           ``vector >& replace)``{``    ``// Initialise a map say unmap, for``    ``// mapping all the characters that``    ``// oldChar can replace with newChar``    ``unordered_map<``char``, unordered_set<``char``> > unmap;``    ``int` `m = S.size(), n = T.size();` `    ``// Iterate over the replace array``    ``// and map in unmap``    ``for` `(``auto` `c : replace) {``        ``unmap].insert(c[1]);``    ``}` `    ``// Iterate over all the subarray in S``    ``// of length equals to given string T.``    ``for` `(``int` `i = 0; i < m - n + 1; i++) {``        ``bool` `flag = ``true``;``        ``for` `(``int` `j = 0; j < n; j++) {` `            ``// Check if the character in S``            ``// is not equal to character``            ``// in T. If not equal then``            ``// check if there exist any``            ``// replacement of T[j] in unmap.``            ``if` `(S[i + j] != T[j]) {` `                ``// If mapping exists, continue``                ``if` `(unmap[T[j]].find(S[i + j])``                    ``!= unmap[T[j]].end()) {``                    ``continue``;``                ``}` `                ``// Otherwise, break from``                ``// current iteration and look``                ``// for the another substring.``                ``else` `{``                    ``flag = ``false``;``                    ``break``;``                ``}``            ``}``        ``}` `        ``// If we successfully found valid``        ``// substring, then return true``        ``if` `(flag)``            ``return` `true``;``    ``}` `    ``// Otherwise, return false``    ``return` `false``;``}` `// Drivers code``int` `main()``{``    ``string S = ``"hoog3e7bar"``, T = ``"geek"``;``    ``vector > replace``        ``= { { ``'e'``, ``'3'` `}, { ``'t'``, ``'7'` `}, { ``'k'``, ``'7'` `} };` `    ``// Function call``    ``bool` `result = match(S, T, replace);` `    ``if` `(result)``        ``cout << ``"YES"` `<< endl;``    ``else``        ``cout << ``"NO"` `<< endl;` `    ``return` `0;``}`

## Java

 `// Java code to implement the approach` `import` `java.io.*;``import` `java.util.*;` `class` `GFG {` `  ``// Function to check if the string``  ``// can be made substring of S``  ``static` `boolean` `match(String S, String T,``                       ``char``[][] replace)``  ``{``    ` `    ``// Initialise a map for mapping all``    ``// the characters that oldChar can``    ``// replace with newChar``    ``Map > unmap``      ``= ``new` `HashMap<>();``    ``int` `m = S.length(), n = T.length();` `    ``// Iterate over the replace array``    ``// and map in unmap``    ``for` `(``char``[] c : replace) {``      ``if` `(!unmap.containsKey(c[``0``])) {``        ``unmap.put(c[``0``], ``new` `HashSet<>());``      ``}``      ``unmap.get(c[``0``]).add(c[``1``]);``    ``}` `    ``// Iterate over all the subarray in S``    ``// of length equals to given string T.``    ``for` `(``int` `i = ``0``; i < m - n + ``1``; i++) {``      ``boolean` `flag = ``true``;``      ``for` `(``int` `j = ``0``; j < n; j++)``      ``{``        ` `        ``// Check if the character in S``        ``// is not equal to character``        ``// in T. If not equal then``        ``// check if there exist any``        ``// replacement of T[j] in unmap.``        ``if` `(S.charAt(i + j) != T.charAt(j))``        ``{``          ` `          ``// If mapping exists, continue``          ``if` `(unmap.containsKey(T.charAt(j))``              ``&& unmap.get(T.charAt(j))``              ``.contains(S.charAt(i + j))) {``            ``continue``;``          ``}``          ` `          ``// Otherwise, break from``          ``// current iteration and look``          ``// for the another substring.``          ``else` `{``            ``flag = ``false``;``            ``break``;``          ``}``        ``}``      ``}` `      ``// If we successfully found valid``      ``// substring, then return true``      ``if` `(flag)``        ``return` `true``;``    ``}` `    ``// Otherwise, return false``    ``return` `false``;``  ``}` `  ``public` `static` `void` `main(String[] args)``  ``{``    ``String S = ``"hoog3e7bar"``, T = ``"geek"``;``    ``char``[][] replace``      ``= { { ``'e'``, ``'3'` `}, { ``'t'``, ``'7'` `}, { ``'k'``, ``'7'` `} };` `    ``// Function call``    ``boolean` `result = match(S, T, replace);` `    ``if` `(result) {``      ``System.out.println(``"YES"``);``    ``}``    ``else` `{``      ``System.out.println(``"NO"``);``    ``}``  ``}``}` `// This code is contributed by lokeshmvs21.`

## Python3

 `# Python code to implement the approach` `# Function to check if the string``# can be made substring of S` `def` `match(S,T,replace):``    ``# Initialise a map say unmap, for``    ``# mapping all the characters that``    ``# oldChar can replace with newChar``    ``unmap``=``{}``    ``m``=``len``(S)``    ``n``=``len``(T)``    ` `    ``# Iterate over the replace array``    ``# and map in unmap``    ``for` `c ``in` `replace:``        ``unmap]``=``c[``1``]``        ` `    ``# Iterate over all the subarray in S``    ``# of length equals to given string T.``    ``for` `i ``in` `range``(m``-``n``+``1``):``        ``flag``=``True``        ``for` `j ``in` `range``(n):``            ``# Check if the character in S``            ``# is not equal to character``            ``# in T. If not equal then``            ``# check if there exist any``            ``# replacement of T[j] in unmap.``            ``if``(S[i``+``j]!``=``T[j]):``                ``# If mapping exists, continue``                ``if` `S[i``+``j] ``in` `unmap.values():``                    ``continue``                ` `                ``# Otherwise, break from``                ``# current iteration and look``                ``# for the another substring.``                ``else``:``                    ``flag``=``False``                    ``break``                ` `        ``# If we successfully found valid``        ``# substring, then return true``        ``if``(flag):``            ``return` `True``    ``# Otherwise, return false``    ``return` `False``    ` `# Driver code``S``=``"hoog3e7bar"``T``=``"geek"``replace``=``[[``'e'``, ``'3'``],[``'t'``, ``'7'``],[``'k'``, ``'7'``]]` `# Function call``result``=``match(S,T,replace)` `if``(result):``    ``print``(``"Yes"``)``else``:``    ``print``(``"No"``)``    `  `# This code is contributed by Pushpesh Raj.`

## Javascript

 `       ``// JavaScript code for the above approach``       ``// Function to check if the string``       ``// can be made substring of S``       ``function` `match(S, T, replace)``       ``{``       ` `           ``// Initialise a map for mapping all``           ``// the characters that oldChar can``           ``// replace with newChar``           ``let unmap = ``new` `Map();``           ``let m = S.length;``           ``let n = T.length;` `           ``// Iterate over the replace array``           ``// and map in unmap``           ``for` `(let c of replace) {``               ``if` `(!unmap.has(c[0])) {``                   ``unmap.set(c[0], ``new` `Set());``               ``}``               ``unmap.get(c[0]).add(c[1]);``           ``}` `           ``// Iterate over all the subarray in S``           ``// of length equals to given string T.``           ``for` `(let i = 0; i < m - n + 1; i++) {``               ``let flag = ``true``;``               ``for` `(let j = 0; j < n; j++)``               ``{``               ` `                   ``// Check if the character in S``                   ``// is not equal to character``                   ``// in T. If not equal then``                   ``// check if there exist any``                   ``// replacement of T[j] in unmap.``                   ``if` `(S[i + j] != T[j]) {``                       ``// If mapping exists, continue``                       ``if` `(unmap.has(T[j]) && unmap.get(T[j]).has(S[i + j])) {``                           ``continue``;``                       ``}``                       ``// Otherwise, break from``                       ``// current iteration and look``                       ``// for the another substring.``                       ``else` `{``                           ``flag = ``false``;``                           ``break``;``                       ``}``                   ``}``               ``}` `               ``// If we successfully found valid``               ``// substring, then return true``               ``if` `(flag) ``return` `true``;``           ``}` `           ``// Otherwise, return false` `           ``return` `false``;``       ``}` `       ``// Driver code``       ``let S = ``"hoog3e7bar"``;``       ``let T = ``"geek"``;``       ``let replace = [``           ``[``'e'``, ``'3'``],``           ``[``'t'``, ``'7'``],``           ``[``'k'``, ``'7'``],``       ``];` `       ``// Function call``       ``let result = match(S, T, replace);` `       ``if` `(result) {``           ``console.log(``"YES"``);``       ``} ``else` `{``           ``console.log(``"NO"``);``       ``}` `// This code is contributed by Potta Lokesh`

## C#

 `using` `System;` `using` `System;``using` `System.Collections.Generic;` `public` `class` `Program {``    ``// Function to check if the string``    ``// can be made substring of S``    ``static` `bool` `Match(``string` `S, ``string` `T, ``char``[][] replace)``    ``{``        ``// Initialise a map for mapping all``        ``// the characters that oldChar can``        ``// replace with newChar``        ``Dictionary<``char``, HashSet<``char``> > unmap``            ``= ``new` `Dictionary<``char``, HashSet<``char``> >();``        ``int` `m = S.Length, n = T.Length;` `        ``// Iterate over the replace array``        ``// and map in unmap``        ``foreach``(``char``[] c ``in` `replace)``        ``{``            ``if` `(!unmap.ContainsKey(c[0])) {``                ``unmap.Add(c[0], ``new` `HashSet<``char``>());``            ``}``            ``unmap].Add(c[1]);``        ``}` `        ``// Iterate over all the subarray in S``        ``// of length equals to given string T.``        ``for` `(``int` `i = 0; i < m - n + 1; i++) {``            ``bool` `flag = ``true``;``            ``for` `(``int` `j = 0; j < n; j++) {``                ``// Check if the character in S``                ``// is not equal to character``                ``// in T. If not equal then``                ``// check if there exist any``                ``// replacement of T[j] in unmap.``                ``if` `(S[i + j] != T[j]) {``                    ``// If mapping exists, continue``                    ``if` `(unmap.ContainsKey(T[j])``                        ``&& unmap[T[j]].Contains(S[i + j])) {``                        ``continue``;``                    ``}``                    ``// Otherwise, break from``                    ``// current iteration and look``                    ``// for the another substring.``                    ``else` `{``                        ``flag = ``false``;``                        ``break``;``                    ``}``                ``}``            ``}` `            ``// If we successfully found valid``            ``// substring, then return true``            ``if` `(flag)``                ``return` `true``;``        ``}` `        ``// Otherwise, return false``        ``return` `false``;``    ``}` `    ``static` `public` `void` `Main(``string``[] args)``    ``{``        ``string` `S = ``"hoog3e7bar"``, T = ``"geek"``;``        ``char``[][] replace = { ``new` `char``[] { ``'e'``, ``'3'` `},``                             ``new` `char``[] { ``'t'``, ``'7'` `},``                             ``new` `char``[] { ``'k'``, ``'7'` `} };` `        ``// Function call``        ``bool` `result = Match(S, T, replace);` `        ``if` `(result) {``            ``Console.WriteLine(``"YES"``);``        ``}``        ``else` `{``            ``Console.WriteLine(``"NO"``);``        ``}``    ``}``}`

Output

`YES`

Time Complexity: O(N * M) where N and M are the length of the strings T and S respectively.
Auxiliary Space: O(D) where D is the size of the array replace[][].

Related Articles:

My Personal Notes arrow_drop_up