Related Articles

# CamelCase Pattern Matching

• Difficulty Level : Hard
• Last Updated : 16 Jun, 2021

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& words,``               ``string pattern)``{` `    ``// Map to store the hashing``    ``// of each words with every``    ``// uppercase letter found``    ``map > 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 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 words,``               ``String pattern)``{`` ` `    ``// Map to store the hashing``    ``// of each words with every``    ``// uppercase letter found``    ``Map> map = ``new` `HashMap>();`` ` `    ``// 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> 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 list(List list, String str) {``    ``List temp = ``new` `ArrayList();``    ``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 words = ``new` `ArrayList(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 words,``               ``String pattern)``{``  ` `    ``// Map to store the hashing``    ``// of each words with every``    ``// uppercase letter found``    ``Dictionary> map = ``new` `Dictionary>();``  ` `    ``// 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> 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 list(List list, String str) {``    ``List temp = ``new` `List();``    ``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 words = ``new` `List(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 list containing the strings and M is the length of longest string.

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#

 `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 > 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 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 reseting``            ``// 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``}`
Output
```HiTech
HiTechWorld
HiTechCity
HiTechLab```

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up