 GeeksforGeeks App
Open App Browser
Continue

# Find all strings that match specific pattern in a dictionary

Given a dictionary of words, find all strings that match the given pattern where every character in the pattern is uniquely mapped to a character in the dictionary.

Examples:

```Input:
dict = ["abb", "abc", "xyz", "xyy"];
pattern = "foo"
Output: [xyy abb]
xyy and abb have same character at
index 1 and 2 like the pattern

Input:
dict = ["abb", "abc", "xyz", "xyy"];
pat = "mno"
Output: [abc xyz]
abc and xyz have all distinct characters,
similar to the pattern.

Input:
dict = ["abb", "abc", "xyz", "xyy"];
pattern = "aba"
Output: []
Pattern has same character at index 0 and 2.
No word in dictionary follows the pattern.

Input:
dict = ["abab", "aba", "xyz", "xyx"];
pattern = "aba"
Output: [aba xyx]
aba and xyx have same character at
index 0 and 2 like the pattern```
Recommended Practice

Method 1:

Approach: The aim is to find whether the word has the same structure as the pattern. An approach to this problem can be to make a hash of the word and pattern and compare if they are equal or not. In simple language, we assign different integers to the distinct characters of the word and make a string of integers (hash of the word) according to the occurrence of a particular character in that word and then compare it with the hash of the pattern.

Example:

```Word='xxyzzaabcdd'
Pattern='mmnoopplfmm'
For word-:
map['x']=1;
map['y']=2;
map['z']=3;
map['a']=4;
map['b']=5;
map['c']=6;
map['d']=7;
Hash for Word="11233445677"

For Pattern-:
map['m']=1;
map['n']=2;
map['o']=3;
map['p']=4;
map['l']=5;
map['f']=6;
Hash for Pattern="11233445611"
Therefore in the given example Hash of word
is not equal to Hash of pattern so this word
is not included in the answer```

Algorithm :

• Encode the pattern according to the above approach and store the corresponding hash of the pattern in a string variable hash.
• Algorithm to encode -:
• Initialize a counter i=0 which will map distinct character with distinct integers.
• Read the string and if the current character is not mapped to an integer, map it to the counter value and increment it.
• Concatenate the integer mapped to the current character to the hash string.
• Now read each word and make a hash of it using the same algorithm.
• If the hash of the current word is equal to the hash of the pattern then that word is included in the final answer.

Pseudo Code:

```int i=0
Declare map
for character in pattern:
if(map[character]==map.end())
map[character]=i++;

hash_pattern+=to_string(mp[character])

for words in dictionary:
i=0;
Declare map
if(words.length==pattern.length)
for character in words:
if(map[character]==map.end())
map[character]=i++

hash_word+=to_string(map[character)

if(hash_word==hash_pattern)
print words```

## C++

 `// C++ program to print all``// the strings that match the``// given pattern where every``// character in the pattern is``// uniquely mapped to a character``// in the dictionary``#include ``using` `namespace` `std;` `// Function to encode given string``string encodeString(string str)``{``    ``unordered_map<``char``, ``int``> map;``    ``string res = ``""``;``    ``int` `i = 0;` `    ``// for each character in given string``    ``for` `(``char` `ch : str) {` `        ``// If the character is occurring``        ``// for the first time, assign next``        ``// unique number to that char``        ``if` `(map.find(ch) == map.end())``            ``map[ch] = i++;` `        ``// append the number associated``        ``// with current character into the``        ``// output string``        ``res += to_string(map[ch]);``    ``}` `    ``return` `res;``}` `// Function to print all the``// strings that match the``// given pattern where every``// character in the pattern is``// uniquely mapped to a character``// in the dictionary``void` `findMatchedWords(unordered_set dict,``                      ``string pattern)``{``    ``// len is length of the pattern``    ``int` `len = pattern.length();` `    ``// Encode the string``    ``string hash = encodeString(pattern);` `    ``// for each word in the dictionary``    ``for` `(string word : dict) {``        ``// If size of pattern is same as``        ``// size of current dictionary word``        ``// and both pattern and the word``        ``// has same hash, print the word``        ``if` `(word.length() == len``            ``&& encodeString(word) == hash)``            ``cout << word << ``" "``;``    ``}``}` `// Driver code``int` `main()``{``    ``unordered_set dict = { ``"abb"``, ``"abc"``,``                                   ``"xyz"``, ``"xyy"` `};``    ``string pattern = ``"foo"``;` `    ``findMatchedWords(dict, pattern);` `    ``return` `0;``}`

## Java

 `// Java program to print all the``// strings that match the``// given pattern where every``// character in the pattern is``// uniquely mapped to a character``// in the dictionary``import` `java.io.*;``import` `java.util.*;` `class` `GFG {` `    ``// Function to encode given string``    ``static` `String encodeString(String str)``    ``{``        ``HashMap map = ``new` `HashMap<>();``        ``String res = ``""``;``        ``int` `i = ``0``;` `        ``// for each character in given string``        ``char` `ch;``        ``for` `(``int` `j = ``0``; j < str.length(); j++) {``            ``ch = str.charAt(j);` `            ``// If the character is occurring for the first``            ``// time, assign next unique number to that char``            ``if` `(!map.containsKey(ch))``                ``map.put(ch, i++);` `            ``// append the number associated with current``            ``// character into the output string``            ``res += map.get(ch);``        ``}` `        ``return` `res;``    ``}` `    ``// Function to print all``    ``// the strings that match the``    ``// given pattern where every``    ``// character in the pattern is``    ``// uniquely mapped to a character``    ``// in the dictionary``    ``static` `void` `findMatchedWords(``        ``String[] dict, String pattern)``    ``{``        ``// len is length of the pattern``        ``int` `len = pattern.length();` `        ``// encode the string``        ``String hash = encodeString(pattern);` `        ``// for each word in the dictionary array``        ``for` `(String word : dict) {``            ``// If size of pattern is same``            ``// as size of current``            ``// dictionary word and both``            ``// pattern and the word``            ``// has same hash, print the word``            ``if` `(word.length() == len``                ``&& encodeString(word).equals(hash))``                ``System.out.print(word + ``" "``);``        ``}``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String args[])``    ``{``        ``String[] dict = { ``"abb"``, ``"abc"``,``                          ``"xyz"``, ``"xyy"` `};``        ``String pattern = ``"foo"``;` `        ``findMatchedWords(dict, pattern);``    ``}` `    ``// This code is contributed``    ``// by rachana soma``}`

## Python3

 `# Python3 program to print all the``# strings that match the``# given pattern where every``# character in the pattern is``# uniquely mapped to a character``# in the dictionary` `# Function to encode``# given string``def` `encodeString(``Str``):``  ` `    ``map` `=` `{}``    ``res ``=` `""``    ``i ``=` `0` `    ``# For each character``    ``# in given string``    ``for` `ch ``in` `Str``:` `        ``# If the character is occurring``        ``# for the first time, assign next``        ``# unique number to that char``        ``if` `ch ``not` `in` `map``:``            ``map``[ch] ``=` `i``            ``i ``+``=` `1``            ` `        ``# Append the number associated``        ``# with current character into``        ``# the output string``        ``res ``+``=` `str``(``map``[ch])``    ``return` `res` `# Function to print all``# the strings that match the``# given pattern where every``# character in the pattern is``# uniquely mapped to a character``# in the dictionary``def` `findMatchedWords(``dict``, pattern):` `    ``# len is length of the``    ``# pattern``    ``Len` `=` `len``(pattern)` `    ``# Encode the string``    ``hash` `=` `encodeString(pattern)` `    ``# For each word in the``    ``# dictionary array``    ``for` `word ``in` `dict``:` `        ``# If size of pattern is same``          ``# as size of current``        ``# dictionary word and both``        ``# pattern and the word``        ``# has same hash, print the word``        ``if``(``len``(word) ``=``=` `Len` `and``           ``encodeString(word) ``=``=` `hash``):``            ``print``(word, end ``=` `" "``)` `# Driver code``dict` `=` `[``"abb"``, ``"abc"``,``"xyz"``, ``"xyy"` `]``pattern ``=` `"foo"``findMatchedWords(``dict``, pattern)` `# This code is contributed by avanitrachhadiya2155`

## C#

 `// C# program to print all the strings``// that match the given pattern where``// every character in the pattern is``// uniquely mapped to a character in the dictionary``using` `System;``using` `System.Collections.Generic;``public` `class` `GFG {` `    ``// Function to encode given string``    ``static` `String encodeString(String str)``    ``{``        ``Dictionary<``char``, ``int``> map = ``new` `Dictionary<``char``, ``int``>();``        ``String res = ``""``;``        ``int` `i = 0;` `        ``// for each character in given string``        ``char` `ch;``        ``for` `(``int` `j = 0; j < str.Length; j++) {``            ``ch = str[j];` `            ``// If the character is occurring for the first``            ``// time, assign next unique number to that char``            ``if` `(!map.ContainsKey(ch))``                ``map.Add(ch, i++);` `            ``// append the number associated with current``            ``// character into the output string``            ``res += map[ch];``        ``}` `        ``return` `res;``    ``}` `    ``// Function to print all the``    ``// strings that match the``    ``// given pattern where every``    ``// character in the pattern is``    ``// uniquely mapped to a character``    ``// in the dictionary``    ``static` `void` `findMatchedWords(String[] dict, String pattern)``    ``{``        ``// len is length of the pattern``        ``int` `len = pattern.Length;` `        ``// encode the string``        ``String hash = encodeString(pattern);` `        ``// for each word in the dictionary array``        ``foreach``(String word ``in` `dict)``        ``{``            ``// If size of pattern is same as``            ``// size of current dictionary word``            ``// and both pattern and the word``            ``// has same hash, print the word``            ``if` `(word.Length == len && encodeString(word).Equals(hash))``                ``Console.Write(word + ``" "``);``        ``}``    ``}` `    ``// Driver code``    ``public` `static` `void` `Main(String[] args)``    ``{``        ``String[] dict = { ``"abb"``, ``"abc"``, ``"xyz"``, ``"xyy"` `};``        ``String pattern = ``"foo"``;` `        ``findMatchedWords(dict, pattern);``    ``}``}` `// This code is contributed by 29AjayKumar`

## Javascript

 ``

Output

`xyy abb `

Complexity Analysis:

• Time Complexity: O(N*K).
Here ‘N’ is the number of words and ‘K’ is its length. As we have to traverse each word separately to create its hash.
• Auxiliary Space: O(N).
The use of hash_map data structure for mapping characters takes this amount of space.

Method 2:

Approach: Now let’s discuss a little more conceptual approach which is an even better application of maps. Instead of making a hash for each word we can map the letters of the pattern itself with the corresponding letter of the word. In case the current character has not been mapped, map it to the corresponding character of the word and if it has already been mapped, then check whether the value with which it was mapped earlier is the same as the current value of the word or not. The example below will make things easy to understand.

Example:

```Word='xxyzzaa'
Pattern='mmnoopp'
Step 1-: map['m'] = x
Step 2-: 'm' is already mapped to some value,
check whether that value is equal to current
character of word-:YES ('m' is mapped to x).
Step 3-: map['n'] = y
Step 4-: map['o'] = z
Step 5-: 'o' is already mapped to some value,
check whether that value is equal to current
character of word-:YES ('o' is mapped to z).
Step 6-: map['p'] = a
Step 7-: 'p' is already mapped to some value,
check whether that value is equal to current
character of word-: YES ('p' is mapped to a).
No contradiction so current word matches the pattern```

Algorithm :

1. Create a character array in which we can map the characters of patterns with a corresponding character of a word.
2. Firstly check whether the length of word and pattern is equal or not, if no then check the next word.
3. If the length is equal, traverse the pattern and if the current character of the pattern has not been mapped yet, map it to the corresponding character of the word.
4. If the current character is mapped, then check whether the character with which it has been mapped is equal to the current character of the word.
5. If no then the word does not follow the given pattern.
6. If the word follows the pattern until the last character then print the word.

Pseudo Code:

```for words in dictionary:
char arr_map=0
char map_word=0
if(words.length==pattern.length)
for 0 to length of pattern:
if(arr_map[character in pattern]==0 && map_word[character in word]==0)
arr_map[character in pattern]=word[character in word]
map_word[character in word]=pattern[character in pattern]

else if(arr_map[character]!=word[character] ||map_word[character]!=pattern[character] )
break the loop

If above loop runs successfully
Print(words)```

## C++

 `// C++ program to print all``// the strings that match the``// given pattern where every``// character in the pattern is``// uniquely mapped to a character``// in the dictionary``#include ``using` `namespace` `std;` `bool` `check(string pattern, string word)``{``    ``if` `(pattern.length() != word.length())``        ``return` `false``;` `    ``char` `ch = { 0 };``      ``char` `map_word={ 0};` `    ``int` `len = word.length();` `    ``for` `(``int` `i = 0; i < len; i++) {``        ``if` `(ch[pattern[i]] == 0 && map_word[word[i] ]==0)``        ``{``          ``ch[pattern[i]] = word[i];``          ``map_word[word[i] ]=pattern[i];``        ``}``        ``else` `if` `(ch[pattern[i]] != word[i] || map_word[word[i] ]!=pattern[i])``            ``return` `false``;``    ``}` `    ``return` `true``;``}` `// Function to print all the``// strings that match the``// given pattern where every``// character in the pattern is``// uniquely mapped to a character``// in the dictionary``void` `findMatchedWords(unordered_set dict,``                      ``string pattern)``{``    ``// len is length of the pattern``    ``int` `len = pattern.length();` `    ``// for each word in the dictionary``    ``for` `(string word : dict) {` `        ``if` `(check(pattern, word))``            ``cout << word << ``" "``;``    ``}``}` `// Driver code``int` `main()``{``    ``unordered_set dict = { ``"abb"``, ``"abc"``, ``"xyz"``, ``"xyy"` `,``"bbb"``};``    ``string pattern = ``"foo"``;` `    ``findMatchedWords(dict, pattern);` `    ``return` `0;``}` `// This code is contributed by Ankur Goel And Priobrata Malik`

## Java

 `// Java program to print all``// the strings that match the``// given pattern where every``// character in the pattern is``// uniquely mapped to a character``// in the dictionary``import` `java.util.*;``class` `GFG``{``  ``static` `boolean` `check(String pattern, String word)``  ``{` `    ``if` `(pattern.length() != word.length())``      ``return` `false``;` `    ``int``[] ch = ``new` `int``[``128``];``    ``int` `Len = word.length();` `    ``for``(``int` `i = ``0``; i < Len; i++)``    ``{``      ``if` `(ch[(``int``)pattern.charAt(i)] == ``0``)``      ``{``        ``ch[(``int``)pattern.charAt(i)] = word.charAt(i);``      ``}``      ``else` `if` `(ch[(``int``)pattern.charAt(i)] != word.charAt(i))``      ``{``        ``return` `false``;``      ``}``    ``}``    ``return` `true``;``  ``}` `  ``// Function to print all the``  ``// strings that match the``  ``// given pattern where every``  ``// character in the pattern is``  ``// uniquely mapped to a character``  ``// in the dictionary``  ``static` `void` `findMatchedWords(HashSet dict, String pattern)``  ``{` `    ``// len is length of the pattern``    ``int` `Len = pattern.length();` `    ``// For each word in the dictionary``    ``String result = ``" "``;``    ``for``(String word : dict)``    ``{``      ``if` `(check(pattern, word))``      ``{``        ``result = word + ``" "` `+ result;``      ``}``    ``}``    ``System.out.print(result);``  ``}` `  ``// Driver code``  ``public` `static` `void` `main(String[] args) {``    ``HashSet dict = ``new` `HashSet();``    ``dict.add(``"abb"``);``    ``dict.add(``"abc"``);``    ``dict.add(``"xyz"``);``    ``dict.add(``"xyy"``);` `    ``String pattern = ``"foo"``;` `    ``findMatchedWords(dict, pattern);``  ``}``}` `// This code is contributed by divyeshrabadiya07`

## Python3

 `# Python3 program to print all``# the strings that match the``# given pattern where every``# character in the pattern is``# uniquely mapped to a character``# in the dictionary``def` `check(pattern, word):``    ` `    ``if` `(``len``(pattern) !``=` `len``(word)):``        ``return` `False` `    ``ch ``=` `[``0` `for` `i ``in` `range``(``128``)]` `    ``Len` `=` `len``(word)` `    ``for` `i ``in` `range``(``Len``):``        ``if` `(ch[``ord``(pattern[i])] ``=``=` `0``):``            ``ch[``ord``(pattern[i])] ``=` `word[i]``        ``else` `if` `(ch[``ord``(pattern[i])] !``=` `word[i]):``            ``return` `False``    ` `    ``return` `True` `# Function to print all the``# strings that match the``# given pattern where every``# character in the pattern is``# uniquely mapped to a character``# in the dictionary``def` `findMatchedWords(``Dict``, pattern):``    ` `    ``# len is length of the pattern``    ``Len` `=` `len``(pattern)` `    ``# For each word in the dictionary``    ``for` `word ``in` `range``(``len``(``Dict``) ``-` `1``, ``-``1``, ``-``1``):``        ``if` `(check(pattern, ``Dict``[word])):``            ``print``(``Dict``[word], end ``=` `" "``)` `# Driver code``Dict` `=` `[ ``"abb"``, ``"abc"``, ``"xyz"``, ``"xyy"` `]``pattern ``=` `"foo"` `findMatchedWords(``Dict``, pattern)` `# This code is contributed by rag2127`

## C#

 `// C# program to print all``// the strings that match the``// given pattern where every``// character in the pattern is``// uniquely mapped to a character``// in the dictionary``using` `System;``using` `System.Collections;``using` `System.Collections.Generic;` `class` `GFG{``    ` `static` `bool` `check(``string` `pattern, ``string` `word)``{``    ` `    ``if` `(pattern.Length != word.Length)``        ``return` `false``;``    ` `    ``int``[] ch = ``new` `int``;``    ``int` `Len = word.Length;``    ` `    ``for``(``int` `i = 0; i < Len; i++)``    ``{``        ``if` `(ch[(``int``)pattern[i]] == 0)``        ``{``            ``ch[(``int``)pattern[i]] = word[i];``        ``}``        ``else` `if` `(ch[(``int``)pattern[i]] != word[i])``        ``{``            ``return` `false``;``        ``}``    ``}``    ``return` `true``;``}` `// Function to print all the``// strings that match the``// given pattern where every``// character in the pattern is``// uniquely mapped to a character``// in the dictionary``static` `void` `findMatchedWords(HashSet<``string``> dict,``                             ``string` `pattern)``{``    ` `    ``// len is length of the pattern``    ``int` `Len = pattern.Length;`` ` `    ``// For each word in the dictionary``    ``string` `result = ``" "``;``    ``foreach``(``string` `word ``in` `dict)``    ``{``        ``if` `(check(pattern, word))``        ``{``            ``result = word + ``" "` `+ result;``        ``}``    ``}``    ``Console.Write(result);``}` `// Driver Code   ``static` `void` `Main()``{``    ``HashSet<``string``> dict = ``new` `HashSet<``string``>(``        ``new` `string``[]{ ``"abb"``, ``"abc"``, ``"xyz"``, ``"xyy"` `});``    ` `    ``string` `pattern = ``"foo"``;``    ` `    ``findMatchedWords(dict, pattern);``}``}` `// This code is contributed by divyesh072019`

## Javascript

 ``

Output

`xyy abb `

Complexity Analysis:

• Time Complexity: O(N*K), where ‘N’ is the number of words and ‘K’ is its length.
To traverse each word, this will be the time requirement.
• Auxiliary Space:O(N).
The use of hash_map data structure for mapping characters consumes N space.