Find all strings that match specific pattern in a dictionary
Last Updated :
04 Jul, 2022
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
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 <bits/stdc++.h>
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<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
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<string> dict = { "abb", "abc",
"xyz", "xyy" };
string pattern = "foo";
findMatchedWords(dict, pattern);
return 0;
}
// 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<Character, Integer> 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 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# 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
<script>
// Javascript 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
function encodeString(str)
{
let map = new Map();
let res = "";
let i = 0;
// for each character in given string
let ch;
for (let 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.has(ch))
map.set(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
function findMatchedWords(dict, pattern)
{
// len is length of the pattern
let len = pattern.length;
// encode the string
let hash = encodeString(pattern);
// for each word in the dictionary array
for (let word=0;word< dict.length;word++) {
// 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 (dict[word].length == len
&& encodeString(dict[word]) == (hash))
document.write(dict[word] + " ");
}
}
// Driver code
let dict=["abb", "abc","xyz", "xyy"];
let pattern = "foo";
findMatchedWords(dict, pattern);
// This code is contributed by unknown2108
</script>
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 :
- Create a character array in which we can map the characters of patterns with a corresponding character of a word.
- Firstly check whether the length of word and pattern is equal or not, if no then check the next word.
- 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.
- 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.
- If no then the word does not follow the given pattern.
- If the word follows the pattern until the last character then print the word.
Pseudo Code:
for words in dictionary:
char arr_map[128]=0
char map_word[128]=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 <bits/stdc++.h>
using namespace std;
bool check(string pattern, string word)
{
if (pattern.length() != word.length())
return false;
char ch[128] = { 0 };
char map_word[128]={ 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<string> 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<string> 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 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<String> 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<String> dict = new HashSet<String>();
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 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# 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[128];
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
<script>
// Javascript 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 check(pattern, word)
{
if (pattern.length != word.length)
return false;
let ch = new Array(128);
for(let i=0;i<128;i++)
{
ch[i]=0;
}
let Len = word.length;
for(let i = 0; i < Len; i++)
{
if (ch[pattern[i].charCodeAt(0)] == 0)
{
ch[pattern[i].charCodeAt(0)] = word[i];
}
else if (ch[pattern[i].charCodeAt(0)] != 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
function findMatchedWords(dict,pattern)
{
// len is length of the pattern
let Len = pattern.length;
// For each word in the dictionary
let result = " ";
for(let word of dict.values())
{
if (check(pattern, word))
{
result = word + " " + result;
}
}
document.write(result);
}
// Driver code
let dict = new Set();
dict.add("abb");
dict.add("abc");
dict.add("xyz");
dict.add("xyy");
let pattern = "foo";
findMatchedWords(dict, pattern);
// This code is contributed by patel2127
</script>
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.
Similar Reads
Find the first repeated word in a string in Python using Dictionary
We are given a string that may contain repeated words and the task is to find the first word that appears more than once. For example, in the string "Learn code learn fast", the word "learn" is the first repeated word. Let's understand different approaches to solve this problem using a dictionary. U
3 min read
Match a pattern and String without using regular expressions
Given two strings, word and pat, your task is to check if the string word follows the pattern of string pat. If the string follows the pattern, find the substring associated with each character of the given pattern string, else print -1.Examples:Input: word = "GraphTreesGraph", pat = "aba"Output: a
11 min read
Search a string in the dictionary with a given prefix and suffix for Q queries
Given an array arr[] consisting of N strings and Q queries in form of two strings prefix and suffix, the task for each query is to find any one string in the given array with the given prefix and suffix. If there exists no such string then print "-1". Examples: Input: arr[] = {"apple", "app", "biscu
15+ min read
Python - Find all close matches of input string from a list
In Python, there are multiple ways to find all close matches of a given input string from a list of strings. Using startswith() startswith() function is used to identify close matches for the input string. It checks if either the strings in the list start with the input or if the input starts with t
3 min read
Suffix Tree Application 2 - Searching All Patterns
Given a text string and a pattern string, find all occurrences of the pattern in string. Few pattern searching algorithms (KMP, Rabin-Karp, Naive Algorithm, Finite Automata) are already discussed, which can be used for this check. Here we will discuss the suffix tree based algorithm. In the 1st Suff
15+ min read
Sentence that contains all the given phrases
Given a list of sentences and a list of phrases. The task is to find which sentence(s) contain all the words in a phrase and for every phrase print the sentences number that contains the given phrase. Constraint: A word cannot be a part of more than 10 sentences. Examples: Input:Â Sentences: 1. Stri
8 min read
Pattern Searching using C++ library
Given a text txt[0..n-1] and a pattern pat[0..m-1], write a function that prints all occurrences of pat[] in txt[]. You may assume that n > m.Examples: Input : txt[] = "geeks for geeks" pat[] = "geeks" Output : Pattern found at index 0 Pattern found at index 10 Input : txt[] = "aaaa" pat[] = "aa"
3 min read
Introduction to Pattern Searching - Data Structure and Algorithm Tutorial
Pattern searching is an algorithm that involves searching for patterns such as strings, words, images, etc. We use certain algorithms to do the search process. The complexity of pattern searching varies from algorithm to algorithm. They are very useful when performing a search in a database. The Pat
15+ min read
Finite Automata algorithm for Pattern Searching
Given a text txt[0..n-1] and a pattern pat[0..m-1], write a function search(char pat[], char txt[]) that prints all occurrences of pat[] in txt[]. You may assume that n > m.Examples: Input: txt[] = "THIS IS A TEST TEXT" pat[] = "TEST" Output: Pattern found at index 10 Input: txt[] = "AABAACAADAAB
13 min read
Find frequency of each word in a string in Python
Write a python code to find the frequency of each word in a given string. Examples: Input : str[] = "Apple Mango Orange Mango Guava Guava Mango" Output : frequency of Apple is : 1 frequency of Mango is : 3 frequency of Orange is : 1 frequency of Guava is : 2 Input : str = "Train Bus Bus Train Taxi A
7 min read