Skip to content
Related Articles

Related Articles

CamelCase Pattern Matching

Improve Article
Save Article
  • Difficulty Level : Hard
  • Last Updated : 08 Nov, 2022
Improve Article
Save Article

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




// C++ to find CamelCase Pattern
// matching
#include "bits/stdc++.h"
using namespace std;
 
// Function that prints the camel
// case pattern matching
void 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 Code
int 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




// Java to find CamelCase Pattern
// matching
import java.util.*;
 
class GFG {
 
    // Function that prints the camel
    // case pattern matching
    static 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 Code
    public 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




# Python3 to find CamelCase Pattern
# matching
 
# Function that prints the camel
# case pattern matching
 
 
def 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 Code
if __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#




// C# to find CamelCase Pattern
// matching
using System;
using System.Collections.Generic;
 
class GFG {
 
    // Function that prints the camel
    // case pattern matching
    static 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 Code
    public 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


Output

HiTech
HiTechWorld
HiTechCity
HiTechLab

Time Complexity: O(N*M) where N is the length of the list containing the strings and M is the length of the longest string.
Auxiliary Space: O(N*M)

Efficient Approach:

  1. Prepare a string by concatenating all array elements & semicolon as a delimiter after every array element.
  2. Traverse through concatenated string and look for Upper Case characters or delimiter.
  3. 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.
  4. Once delimiter reached, reset the temporary variables.

Below is the implementation of the above approach:

C++




#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 code
int 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


Java




// Java Code for above approach
import java.util.*;
 
public class Solution {
  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 = "";
    for (int i = 0; i < arr.length; i++) {
      cctdString += arr[i];
      if (i != arr.length - 1)
        cctdString += ';';
    }
 
    // Map to store the hashing
    // of each words with every
    // uppercase letter found
    HashMap<String, ArrayList<String> > maps
      = new HashMap<>();
 
    // 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.charAt(charPos) >= 'A'
          && cctdString.charAt(charPos) <= 'Z') {
        strr += cctdString.charAt(charPos);
 
        // If pattern matches then
        // print the corresponding
        // mapped words
        if (maps.containsKey(strr)) {
          ArrayList<String> temp
            = new ArrayList<>();
          temp = maps.getOrDefault(
            strr, new ArrayList<>());
          temp.add(arr[wordPos]);
          maps.put(strr, temp);
        }
        else {
          ArrayList<String> temp
            = new ArrayList<>();
          temp.add(arr[wordPos]);
          maps.put(strr, temp);
        }
      }
 
      // If delimiter has reached then resetting
      // temporary string also incrementing word
      // position value
      else if (cctdString.charAt(charPos) == ';') {
        wordPos++;
        strr = "";
      }
    }
 
    // If pattern matches then
    // print the corresponding
    // mapped words
    if (maps.containsKey(pattern)) {
      for (int i = 0;
           i < maps.getOrDefault(pattern,
                                 new ArrayList<>())
           .size();
           i++) {
        System.out.println(
          maps.get(pattern).get(i));
      }
    }
    else {
      System.out.println("No Match Found");
    }
  }
 
  // Driver 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 karandeep1234


C#




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
}


Python3




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 code
if __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


Output

HiTech
HiTechWorld
HiTechCity
HiTechLab

Time Complexity: O(N)
Auxiliary Space: O(N) 


My Personal Notes arrow_drop_up
Related Articles

Start Your Coding Journey Now!