在字典中查找与特定模式匹配的所有字符串

给定一个单词字典，找到与给定模式匹配的所有字符串，其中模式中的每个字符都唯一地映射到字典中的一个字符。

例子：

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

方法一：
方法：目的是找出单词是否与模式具有相同的结构。解决这个问题的一种方法是对单词和模式进行散列，然后比较它们是否相等。在简单的语言中，我们为单词的不同字符分配不同的整数，并根据该单词中特定字符的出现情况制作字符串整数（单词的哈希） ，然后将其与模式的哈希进行比较。

例子：

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

算法 ：

• 根据上述方法对模式进行编码，并将模式的相应哈希值存储在字符串变量hash 中。
• 编码算法 -：
  • 初始化一个计数器i=0 ，它将用不同的整数映射不同的字符。
  • 读取字符串，如果当前字符未映射到整数，则将其映射到计数器值并递增它。
  • 将映射到当前字符的整数连接到哈希字符串。
• 现在阅读每个单词并使用相同的算法对其进行散列。
• 如果当前单词的哈希值等于模式的哈希值，则该单词将包含在最终答案中。

伪代码：

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 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 map = new Dictionary();
        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

// 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

输出：

xyy abb

复杂度分析：

• 时间复杂度： O(N*K)。
  这里’N’是单词的数量，’K’是它的长度。因为我们必须分别遍历每个单词以创建其哈希。
• 辅助空间： O(N)。
  使用hash_map数据结构来映射字符会占用这个空间。

方法二：

方法：现在让我们讨论一种更概念化的方法，它是地图的更好应用。我们可以将模式本身的字母与该词的相应字母映射，而不是为每个单词制作散列。如果当前字符没有被映射，则将其映射到单词的对应字符，如果已经映射，则检查之前映射的值是否与单词的当前值相同.下面的例子将使事情变得容易理解。

例子：

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

算法 ：

1. 创建的字符阵列中，我们可以用一个字的相应的字符图案中的字符映射。
2. 首先检查单词和模式的长度是否相等，如果不相等则检查下一个单词。
3. 如果长度相等，则遍历模式，如果模式的当前字符尚未映射，则将其映射到单词的对应字符。
4. 如果当前字符被映射，则检查它被映射的字符是否等于单词的当前字符。
5. 如果不是，则该词不遵循给定的模式。
6. 如果单词遵循模式直到最后一个字符，则打印该单词。

伪代码：

for words in dictionary:
   char arr_map[128]=0
   if(words.length==pattern.length)
     for character in pattern:
         if(arr_map[character]==0)
            arr_map[character]=word[character]

          else if(arr_map[character]!=word[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[128] = { 0 };
 
    int len = word.length();
 
    for (int i = 0; i < len; i++) {
        if (ch[pattern[i]] == 0)
            ch[pattern[i]] = word[i];
        else if (ch[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
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" };
    string pattern = "foo";
 
    findMatchedWords(dict, pattern);
 
    return 0;
}
 
// This code is contributed by Ankur Goel

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

蟒蛇3

# 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]
        elif (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[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 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 dict = new HashSet(
        new string[]{ "abb", "abc", "xyz", "xyy" });
     
    string pattern = "foo";
     
    findMatchedWords(dict, pattern);
}
}
 
// This code is contributed by divyesh072019

Javascript

// 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

输出：

xyy abb

复杂度分析：

• 时间复杂度： O(N*K)，其中’N’ 是单词的数量，’K’ 是它的长度。
  要遍历每个单词，这将是时间要求。
• 辅助空间： O(N)。
  使用hash_map数据结构映射字符消耗 N 个空间。

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。