# Match a pattern and String without using regular expressions

• Difficulty Level : Hard
• Last Updated : 25 Jan, 2022

Given a string, find out if string follows a given pattern or not without using any regular expressions.
Examples:

```Input:
string - GraphTreesGraph
pattern - aba
Output:
a->Graph
b->Trees

Input:
string - GraphGraphGraph
pattern - aaa
Output:
a->Graph

Input:
string - GeeksforGeeks
pattern - GfG
Output:
G->Geeks
f->for

Input:
string - GeeksforGeeks
pattern - GG
Output:
No solution exists```

We can solve this problem with the help of Backtracking. For each character in the pattern, if the character is not seen before, we consider all possible sub-strings and recurse to see if it leads to the solution or not. We maintain a map that stores sub-string mapped to a pattern character. If pattern character is seen before, we use the same sub-string present in the map. If we found a solution, for each distinct character in the pattern, we print string mapped to it using our map.
Below is C++ implementation of above idea â€“

## CPP

 `// C++ program to find out if string follows` `// a given pattern or not` `#include ` `using` `namespace` `std;`   `/*  Function to find out if string follows a given` `    ``pattern or not`   `    ``str - given string` `    ``n - length of given string` `    ``i - current index in input string` `    ``pat - given pattern` `    ``m - length of given pattern` `    ``j - current index in given pattern` `    ``map - stores mapping between pattern and string */` `bool` `patternMatchUtil(string str, ``int` `n, ``int` `i,` `                    ``string pat, ``int` `m, ``int` `j,` `                    ``unordered_map<``char``, string>& map)` `{` `    ``// If both string and pattern reach their end` `    ``if` `(i == n && j == m)` `        ``return` `true``;`   `    ``// If either string or pattern reach their end` `    ``if` `(i == n || j == m)` `        ``return` `false``;`   `    ``// read next character from the pattern` `    ``char` `ch = pat[j];`   `    ``// if character is seen before` `    ``if` `(map.find(ch)!= map.end())` `    ``{` `        ``string s = map[ch];` `        ``int` `len = s.size();`   `        ``// consider next len characters of str` `        ``string subStr = str.substr(i, len);`   `        ``// if next len characters of string str` `        ``// don't match with s, return false` `        ``if` `(subStr.compare(s))` `            ``return` `false``;`   `        ``// if it matches, recurse for remaining characters` `        ``return` `patternMatchUtil(str, n, i + len, pat, m,` `                                            ``j + 1, map);` `    ``}`   `    ``// If character is seen for first time, try out all` `    ``// remaining characters in the string` `    ``for` `(``int` `len = 1; len <= n - i; len++)` `    ``{` `        ``// consider substring that starts at position i` `        ``// and spans len characters and add it to map` `        ``map[ch] = str.substr(i, len);`   `        ``// see if it leads to the solution` `        ``if` `(patternMatchUtil(str, n, i + len, pat, m,` `                                          ``j + 1, map))` `            ``return` `true``;`   `        ``// if not, remove ch from the map` `        ``map.erase(ch);` `    ``}`   `    ``return` `false``;` `}`   `// A wrapper over patternMatchUtil()function` `bool` `patternMatch(string str, string pat, ``int` `n, ``int` `m)` `{` `    ``if` `(n < m)` `    ``return` `false``;`   `    ``// create an empty hashmap` `    ``unordered_map<``char``, string> map;`   `    ``// store result in a boolean variable res` `    ``bool` `res = patternMatchUtil(str, n, 0, pat, m, 0, map);`   `    ``// if solution exists, print the mappings` `    ``for` `(``auto` `it = map.begin(); res && it != map.end(); it++)` `        ``cout << it->first << ``"->"` `<< it->second << endl;`   `    ``// return result` `    ``return` `res;` `}`   `// Driver code` `int` `main()` `{` `    ``string str = ``"GeeksforGeeks"``, pat = ``"GfG"``;`   `    ``int` `n = str.size(), m = pat.size();`   `    ``if` `(!patternMatch(str, pat, n, m))` `        ``cout << ``"No Solution exists"``;`   `    ``return` `0;` `}`

## Java

 `import` `java.util.HashMap;` `import` `java.util.Map;`   `class` `Main` `{` `  ``// Function to determine if given pattern matches with a string or not` `  ``public` `static` `boolean` `match(String str, ``int` `i, ` `                              ``String pat, ``int` `j,` `                              ``Map map)` `  ``{` `    ``int` `n = str.length(), m = pat.length();`   `    ``// base condition` `    ``if` `(n < m) {` `      ``return` `false``;` `    ``}`   `    ``// if both pattern and the string reaches end` `    ``if` `(i == n && j == m) {` `      ``return` `true``;` `    ``}`   `    ``// if either string or pattern reaches end` `    ``if` `(i == n || j == m) {` `      ``return` `false``;` `    ``}`   `    ``// consider next character from the pattern` `    ``char` `curr = pat.charAt(j);`   `    ``// if the character is seen before` `    ``if` `(map.containsKey(curr))` `    ``{` `      ``String s = map.get(curr);` `      ``int` `k = s.length();`   `      ``// ss stores next k characters of the given string` `      ``String ss;` `      ``if` `(i + k < str.length()) {` `        ``ss = str.substring(i, i + k);` `      ``} ``else` `{` `        ``ss = str.substring(i);` `      ``}`   `      ``// return false if next k characters doesn't match with s` `      ``if` `(ss.compareTo(s) != ``0``) {` `        ``return` `false``;` `      ``}`   `      ``// recur for remaining characters if next k characters matches` `      ``return` `match(str, i + k, pat, j + ``1``, map);` `    ``}`   `    ``// process all remaining characters in the string if current` `    ``// character is never seen before` `    ``for` `(``int` `k = ``1``; k <= n - i; k++)` `    ``{` `      ``// insert substring formed by next k characters of the string` `      ``// into the map` `      ``map.put(curr, str.substring(i, i + k));`   `      ``// check if it leads to the solution` `      ``if` `(match(str, i + k, pat, j + ``1``, map)) {` `        ``return` `true``;` `      ``}`   `      ``// else backtrack - remove current character from the map` `      ``map.remove(curr);` `    ``}`   `    ``return` `false``;` `  ``}`   `  ``public` `static` `void` `main(String[] args)` `  ``{` `    ``// input string and pattern` `    ``String str = ``"GeeksforGeeks"``;` `    ``String pat = ``"GfG"``;`   `    ``// create a map to store mappings between the pattern and string` `    ``Map map = ``new` `HashMap<>();`   `    ``// check for solution` `    ``if` `(match(str, ``0``, pat, ``0``, map))` `    ``{` `      ``for` `(Map.Entry entry: map.entrySet()) {` `        ``System.out.println(entry.getKey() + ``"->"` `+ entry.getValue());` `      ``}` `    ``}` `    ``else` `{` `      ``System.out.println(``"Solution doesn't exist"``);` `    ``}` `  ``}` `}`   `//This code is contributed by Priyadarshini Kumari`

## Python3

 `# Function to determine if given pattern matches with a string or not` `def` `match(``str``, pat, ``dict``, i``=``0``, j``=``0``):`   `    ``n ``=` `len``(``str``)` `    ``m ``=` `len``(pat)`   `    ``# base condition` `    ``if` `n < m:` `        ``return` `False`   `    ``# if both pattern and the string reaches end` `    ``if` `i ``=``=` `n ``and` `j ``=``=` `m:` `        ``return` `True`   `    ``# if either string or pattern reaches end` `    ``if` `i ``=``=` `n ``or` `j ``=``=` `m:` `        ``return` `False`   `    ``# consider next character from the pattern` `    ``curr ``=` `pat[j]`   `    ``# if the character is seen before` `    ``if` `curr ``in` `dict``:`   `        ``s ``=` `dict``[curr]` `        ``k ``=` `len``(s)`   `        ``# ss stores next k characters of the given string` `        ``if` `i ``+` `k < ``len``(``str``):` `            ``ss ``=` `str``[i:i ``+` `k]` `        ``else``:` `            ``ss ``=` `str``[i:]`   `        ``# return false if next k characters doesn't match with s` `        ``if` `ss !``=` `s:` `            ``return` `False`   `        ``# recur for remaining characters if next k characters matches` `        ``return` `match(``str``, pat, ``dict``, i ``+` `k, j ``+` `1``)`   `    ``# process all remaining characters in the string if current` `    ``# character is never seen before` `    ``for` `k ``in` `range``(``1``, n ``-` `i ``+` `1``):`   `        ``# insert substring formed by next k characters of the string` `        ``# into the dictionary` `        ``dict``[curr] ``=` `str``[i:i ``+` `k]`   `        ``# check if it leads to the solution` `        ``if` `match(``str``, pat, ``dict``, i ``+` `k, j ``+` `1``):` `            ``return` `True`   `        ``# else backtrack - remove current character from the dictionary` `        ``dict``.pop(curr)`   `    ``return` `False`     `if` `__name__ ``=``=` `'__main__'``:`   `    ``# input string and pattern` `    ``str` `=` `"GeeksforGeeks"` `    ``pat ``=` `"GfG"`   `    ``# create a dictionary to store mappings between the pattern and string` `    ``dict` `=` `{}`   `    ``# check for solution` `    ``if` `match(``str``, pat, ``dict``):` `        ``print``(``dict``)` `    ``else``:` `        ``print``(``"Solution doesn't exist"``)`   `# This code is contributed by Priyadarshini Kumari`

## Javascript

 ``

Output:

```f->for
G->Geeks```