GeeksforGeeks App
Open App
Browser
Continue

# CamelCase Pattern Matching

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`

## Javascript

 `// JavaScript to find CamelCase Pattern``// matching``const CamelCase = (words, pattern) => {``  ``// Map to store the hashing``  ``// of each words with every``  ``// uppercase letter found``  ``const map = ``new` `Map();` `  ``// Traverse the words array``  ``// that contains all the``  ``// String``  ``for` `(let i = 0; i < words.length; i++) {``    ``// Initialise str as``    ``// empty``    ``let str = ``""``;` `    ``// length of String words[i]``    ``const l = words[i].length;``    ``for` `(let 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.has(str)) {``          ``const list = map.get(str);``          ``list.push(words[i]);``          ``map.set(str, list);``        ``}``        ``else` `{``          ``map.set(str, [words[i]]);``        ``}``      ``}``    ``}``  ``}` `  ``let wordFound = ``false`

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 ``using` `namespace` `std;` `void` `PrintMatchingCamelCase(vector 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 > 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 temp;``                ``temp.insert(temp.end(), maps[strr].begin(),``                            ``maps[strr].end());``                ``temp.push_back(arr[wordPos]);``                ``maps[strr] = temp;``            ``}``            ``else` `{``                ``vector 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 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 > 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 temp``            ``= ``new` `ArrayList<>();``          ``temp = maps.getOrDefault(``            ``strr, ``new` `ArrayList<>());``          ``temp.add(arr[wordPos]);``          ``maps.put(strr, temp);``        ``}``        ``else` `{``          ``ArrayList 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 > 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 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`

## Javascript

 `// Javascript ptogram for the above approach` `function` `PrintMatchingCamelCase(arr, pattern) {``  ``// Concatenating all array elements``  ``// using semicolon as delimiter after each element``  ``let cctdString = arr.join(``';'``);` `  ``// Map to store the hashing``  ``// of each words with every``  ``// uppercase letter found``  ``let maps = {};` `  ``// temporary Variables``  ``let wordPos = 0;``  ``let strr = ``''``;` `  ``// Traversing through concatenated String``  ``for` `(let charPos = 0; 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` `(strr ``in` `maps) {``        ``let temp = [];``        ``temp = temp.concat(maps[strr]);``        ``temp.push(arr[wordPos]);``        ``maps[strr] = temp;``      ``} ``else` `{``        ``let vec = [arr[wordPos]];``        ``maps[strr] = vec;``      ``}``    ``} ``else` `if` `(cctdString[charPos] === ``';'``) {``      ``// If delimiter has reached then resetting``      ``// temporary string also incrementing word``      ``// position value``      ``wordPos += 1;``      ``strr = ``''``;``    ``}``  ``}` `  ``// If pattern matches then``  ``// print the corresponding``  ``// mapped words``  ``if` `(pattern ``in` `maps) {``    ``for` `(let i = 0; i < maps[pattern].length; i++) {``      ``console.log(maps[pattern][i]);``    ``}``  ``} ``else` `{``    ``console.log(``'No Match Found'``);``  ``}``}` `// Driver code``let arr = [``  ``'Hi'``,``  ``'Hello'``,``  ``'HelloWorld'``,``  ``'HiTech'``,``  ``'HiGeek'``,``  ``'HiTechWorld'``,``  ``'HiTechCity'``,``  ``'HiTechLab'``];` `// Pattern to be found``let pattern = ``'HT'``;` `// Function call to find the``// words that match to the``// given pattern``PrintMatchingCamelCase(arr, pattern);`  `// This code is contributed by codebraxnzt`

Output

```HiTech
HiTechWorld
HiTechCity
HiTechLab```

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

My Personal Notes arrow_drop_up