CamelCase Pattern Matching - GeeksforGeeks

21 Apr, 2022
Given a list of words where each word follows CamelCase notation, the task is to print all words in the dictionary that match with a given pattern consisting of uppercase characters only.
Examples 
Input: arr[] = [ “WelcomeGeek”, “WelcomeToGeeksForGeeks”, “GeeksForGeeks” ], pattern = “WTG” Output: WelcomeToGeeksForGeeks Explanation: There is only one abbreviation for the given pattern i.e., WelcomeToGeeksForGeeks.
Input: arr[] = [ “Hi”, “Hello”, “HelloWorld”, “HiTech”, “HiGeek”, “HiTechWorld”, “HiTechCity”, “HiTechLab” ], pattern = “HA” Output: No match found Explanation: There is no such abbreviation for the given pattern.
Approach: 1. Traverse through every word and keep Hashing that word with every uppercase letter found in the given string. For Example: 
For string = "GeeksForGeeks"
then the hashing after every uppercase letter found is:
map {
     {G, GeeksForGeeks},
     {GF, GeeksForGeeks},
     {GFG, GeeksForGeeks}
} 
2 .After creating hashing for all the string in the list. Search for the given pattern in the map and print all the string mapped to it.
Below is the implementation of the above approach:  
C++
Java
Python3
C#
// C++ to find CamelCase Pattern// matching#include "bits/stdc++.h"using namespace std; // Function that prints the camel// case pattern matchingvoid CamelCase(vector<string>& words,               string pattern){     // Map to store the hashing    // of each words with every    // uppercase letter found    map<string, vector<string> > map;     // Traverse the words array    // that contains all the    // string    for (int i = 0; i < words.size(); i++) {         // Initialise str as        // empty        string str = "";         // length of string words[i]        int l = words[i].length();        for (int j = 0; j < l; j++) {             // For every uppercase            // letter found map            // that uppercase to            // original words            if (words[i][j] >= 'A'                && words[i][j] <= 'Z') {                str += words[i][j];                map[str].push_back(words[i]);            }        }    }     bool wordFound = false;     // Traverse the map for pattern    // matching    for (auto& it : map) {         // If pattern matches then        // print the corresponding        // mapped words        if (it.first == pattern) {            wordFound = true;            for (auto& itt : it.second) {                cout << itt << endl;            }        }    }     // If word not found print    // "No match found"    if (!wordFound) {        cout << "No match found";    }} // Driver's Codeint main(){    vector<string> words = {        "Hi", "Hello", "HelloWorld",        "HiTech", "HiGeek", "HiTechWorld",        "HiTechCity", "HiTechLab"    };     // Pattern to be found    string pattern = "HT";     // Function call to find the    // words that match to the    // given pattern    CamelCase(words, pattern);     return 0;}
// Java to find CamelCase Pattern// matchingimport java.util.*; class GFG{  // Function that prints the camel// case pattern matchingstatic void CamelCase(ArrayList<String> words,               String pattern){      // Map to store the hashing    // of each words with every    // uppercase letter found    Map<String, List<String>> map = new HashMap<String, List<String>>();      // Traverse the words array    // that contains all the    // String    for (int i = 0; i < words.size(); i++) {          // Initialise str as        // empty        String str = "";          // length of String words[i]        int l = words.get(i).length();        for (int j = 0; j < l; j++) {              // For every uppercase            // letter found map            // that uppercase to            // original words            if (words.get(i).charAt(j) >= 'A'                && words.get(i).charAt(j) <= 'Z') {                str += words.get(i).charAt(j);                map.put(str,list(map.get(str),words.get(i)));            }        }    }      boolean wordFound = false;      // Traverse the map for pattern    // matching    for (Map.Entry<String,List<String>> it : map.entrySet()) {          // If pattern matches then        // print the corresponding        // mapped words        if (it.getKey().equals(pattern)) {            wordFound = true;            for(String s : it.getValue())            System.out.print(s +"\n");                     }    }      // If word not found print    // "No match found"    if (!wordFound) {        System.out.print("No match found");    }}  private static List<String> list(List<String> list, String str) {    List<String> temp = new ArrayList<String>();    if(list != null)        temp.addAll(list);    temp.add(str);    return temp;} // Driver's Codepublic static void main(String[] args){    String arr[] = {"Hi", "Hello", "HelloWorld",            "HiTech", "HiGeek", "HiTechWorld",            "HiTechCity", "HiTechLab"        };     ArrayList<String> words = new ArrayList<String>(Arrays.asList(arr));      // Pattern to be found    String pattern = "HT";      // Function call to find the    // words that match to the    // given pattern    CamelCase(words, pattern);  }} // This code is contributed by PrinciRaj1992
# Python3 to find CamelCase Pattern# matching # Function that prints the camel# case pattern matchingdef CamelCase(words, pattern) :     # Map to store the hashing    # of each words with every    # uppercase letter found    map = dict.fromkeys(words,None);     # Traverse the words array    # that contains all the    # string    for i in range(len(words)) :         # Initialise str as        # empty        string = "";         # length of string words[i]        l = len(words[i]);        for j in range(l) :             # For every uppercase            # letter found map            # that uppercase to            # original words            if (words[i][j] >= 'A' and words[i][j] <= 'Z') :                string += words[i][j];                                 if string not in map :                    map[string] = [words[i]]                                     elif map[string] is None :                    map[string] = [words[i]]                                     else :                    map[string].append(words[i]);     wordFound = False;     # Traverse the map for pattern    # matching    for key,value in map.items() :         # If pattern matches then        # print the corresponding        # mapped words        if (key == pattern) :            wordFound = True;            for itt in value :                print(itt);     # If word not found print    # "No match found"    if (not wordFound) :        print("No match found");   # Driver's Codeif __name__ == "__main__" :     words = [        "Hi", "Hello", "HelloWorld",        "HiTech", "HiGeek", "HiTechWorld",        "HiTechCity", "HiTechLab"    ];     # Pattern to be found    pattern = "HT";     # Function call to find the    # words that match to the    # given pattern    CamelCase(words, pattern);     # This code is contributed by AnkitRai01
// C# to find CamelCase Pattern// matchingusing System;using System.Collections.Generic; class GFG{   // Function that prints the camel// case pattern matchingstatic void CamelCase(List<String> words,               String pattern){       // Map to store the hashing    // of each words with every    // uppercase letter found    Dictionary<String, List<String>> map = new Dictionary<String, List<String>>();       // Traverse the words array    // that contains all the    // String    for (int i = 0; i < words.Count; i++) {           // Initialise str as        // empty        String str = "";           // length of String words[i]        int l = words[i].Length;        for (int j = 0; j < l; j++) {               // For every uppercase            // letter found map            // that uppercase to            // original words            if (words[i][j] >= 'A'                && words[i][j] <= 'Z') {                str += words[i][j];                if(map.ContainsKey(str))                    map[str] = list(map[str],words[i]);                else                    map.Add(str,list(null,words[i]));            }        }    }       bool wordFound = false;       // Traverse the map for pattern    // matching    foreach (KeyValuePair<String,List<String>> it in map) {        // If pattern matches then        // print the corresponding        // mapped words        if (it.Key.Equals(pattern)) {            wordFound = true;            foreach(String s in it.Value)            Console.Write(s +"\n");                      }    }       // If word not found print    // "No match found"    if (!wordFound) {        Console.Write("No match found");    }}   private static List<String> list(List<String> list, String str) {    List<String> temp = new List<String>();    if(list != null)        temp.AddRange(list);    temp.Add(str);    return temp;}  // Driver's Codepublic static void Main(String[] args){    String []arr = {"Hi", "Hello", "HelloWorld",            "HiTech", "HiGeek", "HiTechWorld",            "HiTechCity", "HiTechLab"        };      List<String> words = new List<String>(arr);       // Pattern to be found    String pattern = "HT";       // Function call to find the    // words that match to the    // given pattern    CamelCase(words, pattern);   }} // This code is contributed by Rajput-Ji
HiTech
HiTechWorld
HiTechCity
HiTechLab
Time Complexity: O(N*M) where N is the length of list containing the strings and M is the length of longest string. 
Efficient Approach:
Prepare a string by concatenating all array elements & semicolon as a delimiter after every array element.Traverse through concatenated string and look for Upper Case characters or delimiter.Hold a temporary string with all Upper Case characters until delimiter comes in traversal. Add this temporary string as a key (if key doesn’t exist) in dictionary or append the word if key already exists.Once delimiter reached, reset the temporary variables.
Prepare a string by concatenating all array elements & semicolon as a delimiter after every array element.
Traverse through concatenated string and look for Upper Case characters or delimiter.
Hold a temporary string with all Upper Case characters until delimiter comes in traversal. Add this temporary string as a key (if key doesn’t exist) in dictionary or append the word if key already exists.
Once delimiter reached, reset the temporary variables.
Below is the implementation of the above approach:
C++
C#
Python3
#include <bits/stdc++.h>using namespace std; void PrintMatchingCamelCase(vector<string> arr,                            string pattern){   // Concatenating all array elements  // using Aggregate function of LINQ  // putting semicolon as delimiter after each element  string cctdString = "";  for (int i = 0; i < arr.size(); i++) {    cctdString += arr[i];    if (i != arr.size() - 1)      cctdString.push_back(';');  }   // Map to store the hashing  // of each words with every  // uppercase letter found  unordered_map<string, vector<string> > maps;   // temporary Variables  int charPos = 0;  int wordPos = 0;  string strr = "";   // Traversing through concatenated String  for (; charPos < cctdString.length(); charPos++) {     // Identifying if the current Character is    // CamelCase If so, then adding to map    // accordingly    if (cctdString[charPos] >= 'A'        && cctdString[charPos] <= 'Z') {      strr += cctdString[charPos];       // If pattern matches then      // print the corresponding      // mapped words      if (maps.find(strr) != maps.end()) {        vector<string> temp;        temp.insert(temp.end(), maps[strr].begin(),                    maps[strr].end());        temp.push_back(arr[wordPos]);        maps[strr] = temp;      }      else {        vector<string> vec = { arr[wordPos] };        maps[strr] = vec;      }    }     // If delimiter has reached then resetting    // temporary string also incrementing word    // position value    else if (cctdString[charPos] == ';') {      wordPos++;      strr = "";    }  }   // If pattern matches then  // print the corresponding  // mapped words  if (maps.find(pattern) != maps.end()) {    for (int i = 0; i < maps[pattern].size(); i++) {      cout << maps[pattern][i] << endl;    }  }  else {    cout << "No Match Found" << endl;  }} // Driver codeint main(){   // Array of words  vector<string> arr    = { "Hi",         "Hello",    "HelloWorld",       "HiTech",     "HiGeek",   "HiTechWorld",       "HiTechCity", "HiTechLab" };   // Pattern to be found  string pattern = "HT";   // Function call to find the  // words that match to the  // given pattern  PrintMatchingCamelCase(arr, pattern);} // This code is contributed by parthmanchanda81
using System;using System.Collections.Generic;using System.Linq; public class GFG {    public static void    PrintMatchingCamelCase(String[] arr, String pattern)    {        // Concatenating all array elements        // using Aggregate function of LINQ        // putting semicolon as delimiter after each element        String cctdString            = arr.Aggregate((i, j) = > i + ';' + j);        // Map to store the hashing        // of each words with every        // uppercase letter found        Dictionary<String, List<String> > map            = new Dictionary<string, List<string> >();        // temporary Variables        int charPos = 0;        int wordPos = 0;        string strr = string.Empty;         // Traversing through concatenated String        for (; charPos < cctdString.Length; charPos++) {            // Identifying if the current Character is            // CamelCase If so, then adding to map            // accordingly            if (cctdString[charPos] >= 'A'                && cctdString[charPos] <= 'Z') {                strr += cctdString[charPos];                if (map.ContainsKey(strr)) {                    List<String> temp = new List<string>();                    temp.AddRange(map[strr]);                    temp.Add(arr[wordPos]);                    map[strr] = temp;                }                else {                    map.Add(strr, new List<string>{                                      arr[wordPos] });                }            }            // If delimiter has reached then resetting            // temporary string also incrementing word            // position value            else if (cctdString[charPos] == ';') {                wordPos++;                strr = string.Empty;            }        }        // If pattern matches then        // print the corresponding        // mapped words        if (map.ContainsKey(pattern)) {            foreach(String word in map[pattern])            {                Console.WriteLine(word);            }        }        else {            Console.WriteLine("No Match Found");        }    }     // Driver's Code    public static void Main(String[] args)    {        // Array of Words        String[] arr            = { "Hi",         "Hello",    "HelloWorld",                "HiTech",     "HiGeek",   "HiTechWorld",                "HiTechCity", "HiTechLab" };         // Pattern to be found        String pattern = "HT";         // Function call to find the        // words that match to the        // given pattern        PrintMatchingCamelCase(arr, pattern);    }     // This code is contributed by Rishabh Singh}
def PrintMatchingCamelCase(arr, pattern):     # Concatenating all array elements    # using Aggregate function of LINQ    # putting semicolon as delimiter after each element    cctdString = ';'.join(arr)     # Map to store the hashing    # of each words with every    # uppercase letter found    maps = dict()     # temporary Variables    wordPos = 0    strr = ""     # Traversing through concatenated String    for charPos in range(len(cctdString)):         # Identifying if the current Character is        # CamelCase If so, then adding to map        # accordingly        if (cctdString[charPos] >= 'A'                and cctdString[charPos] <= 'Z'):            strr += cctdString[charPos]             # If pattern matches then            # print the corresponding            # mapped words            if strr in maps:                temp = []                temp.extend(maps[strr])                temp.append(arr[wordPos])                maps[strr] = temp             else:                vec = [arr[wordPos], ]                maps[strr] = vec         # If delimiter has reached then resetting        # temporary string also incrementing word        # position value        elif (cctdString[charPos] == ';'):            wordPos += 1            strr = ""     # If pattern matches then    # print the corresponding    # mapped words    if (pattern in maps):        for i in range(len(maps[pattern])):            print(maps[pattern][i])     else:        print("No Match Found")  # Driver codeif __name__ == '__main__':     # Array of words    arr = ["Hi",         "Hello",    "HelloWorld",           "HiTech",     "HiGeek",   "HiTechWorld",           "HiTechCity", "HiTechLab"]     # Pattern to be found    pattern = "HT"     # Function call to find the    # words that match to the    # given pattern    PrintMatchingCamelCase(arr, pattern)  # This code is contributed by Amartya Ghosh
HiTech
HiTechWorld
HiTechCity
HiTechLab
Time Complexity: O(N)Auxiliary Space: O(N) 
ankthon
princiraj1992
Rajput-Ji
rishabhgfg
gabaa406
pankajsharmagfg
parthmanchanda81
amartyaghoshgfg
Advanced Computer Subject
Arrays
Data Structures
Hash
Strings
Data Structures
Arrays
Hash
Strings
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Comments
Old Comments
System Design Tutorial
Copying Files to and from Docker Containers
KDD Process in Data Mining
ML | Underfitting and Overfitting
Clustering in Machine Learning
Arrays in Java
Arrays in C/C++
Program for array rotation
Stack Data Structure (Introduction and Program)
Top 50 Array Coding Problems for Interviews