# Count of strings in Array A that can be made equal to strings in Array B by appending characters

• Difficulty Level : Hard
• Last Updated : 23 Mar, 2022

Given two arrays of strings SearchWord[] and FindWord[]. The task is to check how many strings in FindWord[] can be formed after the following operations on as many strings as possible:

• Pick a string from SearchWord[].
• Add one English alphabet (that is not present in that string).
• Rearrange the string as you like.

Note: Every alphabet in the SearchWord[] and in the FindWord[] are unique and appear only once.

Examples:

Input: SearchWord = {“ge”, “fo”, “ek”}, FindWord = {“gek”, “for”}
Output: 2
Explanation: ‘k’ can be appended to the “ge” to make “gek” which matches the FindWord
‘r’ can be appended to the “fo” to make “for” which matches the FindWord

Input: SearchWord = {“ohr”, “tm”, “ek”}, FindWord = {“mat”, “hr”}
Output: 1

Approach: The simple approach to solving this problem is by sorting and using hashing technique.

• Sort SearchWord[] and FindWord[] in Alphabetical order.
• Apply the reverse logic rather than picking a word from the SearchWord[] array, pick the word from the FindWord[] array.
• And search that word by removing the character one by one and finding the Matching word.

Below is the implementation of the above approach.

## C++

 `// C++ code to implement the above approach``#include ``using` `namespace` `std;` `// Function to find permutation``int` `solution(vector& sw,``             ``vector& tw)``{``    ``unordered_set s;``    ``for` `(``int` `i = 0; i < sw.size(); i++) {``        ``sort(sw[i].begin(), sw[i].end());``        ``s.insert(sw[i]);``    ``}``    ``int` `ans = 0;` `    ``// Loop to check how many string``    ``// can be formed``    ``for` `(``int` `i = 0; i < tw.size(); i++) {``        ``string test = tw[i];``        ``sort(test.begin(), test.end());` `        ``// To track the number``        ``// Of the words formed``        ``bool` `check = 0;` `        ``for` `(``int` `j = 0; j < test.size(); j++) {` `            ``// Substring from 0 to 'i'``            ``// and remove one alphabet``            ``// and append rest of the string``            ``string search``                ``= test.substr(0, j)``                  ``+ test.substr(j + 1);` `            ``// Check if the word is available``            ``// in the set``            ``if` `(s.find(search) != s.end()) {``                ``check = 1;``                ``break``;``            ``}``        ``}``        ``if` `(check)``            ``ans++;``    ``}``    ``return` `ans;``}` `// Driver Code``int` `main()``{``    ``vector str = { ``"ohr"``, ``"tm"``, ``"ek"` `};``    ``vector str1 = { ``"mat"``, ``"hr"` `};` `    ``cout << solution(str, str1);``    ``return` `0;``}`

## Java

 `// Java code to implement the above approach``import` `java.util.*;``class` `GFG{` `  ``// Function to find permutation``  ``static` `int` `solution(String[] sw,``                      ``String[]  tw)``  ``{``    ``HashSet s = ``new` `HashSet<>();``    ``for` `(``int` `i = ``0``; i < sw.length; i++) {``      ``sw[i] = sort(sw[i]);``      ``s.add(sw[i]);``    ``}``    ``int` `ans = ``0``;` `    ``// Loop to check how many String``    ``// can be formed``    ``for` `(``int` `i = ``0``; i < tw.length; i++) {``      ``String test = tw[i];``      ``test = sort(test);` `      ``// To track the number``      ``// Of the words formed``      ``boolean` `check = ``false``;` `      ``for` `(``int` `j = ``0``; j < test.length(); j++) {` `        ``// SubString from 0 to 'i'``        ``// and remove one alphabet``        ``// and append rest of the String``        ``String search``          ``= test.substring(``0``, j)``          ``+ test.substring(j + ``1``);` `        ``// Check if the word is available``        ``// in the set``        ``if` `(s.contains(search)) {``          ``check = ``true``;``          ``break``;``        ``}``      ``}``      ``if` `(check)``        ``ans++;``    ``}``    ``return` `ans;``  ``}``  ``//Method to sort a string alphabetically``  ``static` `String sort(String inputString)``  ``{``    ``// convert input string to char array``    ``char` `tempArray[] = inputString.toCharArray();` `    ``// sort tempArray``    ``Arrays.sort(tempArray);` `    ``// return new sorted string``    ``return` `new` `String(tempArray);``  ``}``  ` `  ``// Driver Code``  ``public` `static` `void` `main(String[] args)``  ``{``    ``String[] str = { ``"ohr"``, ``"tm"``, ``"ek"` `};``    ``String[]  str1 = { ``"mat"``, ``"hr"` `};` `    ``System.out.print(solution(str, str1));``  ``}``}` `// This code is contributed by shikhasingrajput`

## Python3

 `# python3 code to implement the above approach` `# Function to find permutation``def` `solution(sw, tw):` `    ``s ``=` `set``()``    ``for` `i ``in` `range``(``0``, ``len``(sw)):``        ``s.add("".join(``sorted``(``list``(sw[i]))))` `    ``ans ``=` `0` `    ``# Loop to check how many string``    ``# can be formed``    ``for` `i ``in` `range``(``0``, ``len``(tw)):``        ``test ``=` `"".join(``sorted``(``list``(tw[i])))` `        ``# To track the number``        ``# Of the words formed``        ``check ``=` `0` `        ``for` `j ``in` `range``(``0``, ``len``(test)):` `        ``# Substring from 0 to 'i'``        ``# and remove one alphabet``        ``# and append rest of the string``            ``search ``=` `test[:j] ``+` `test[j ``+` `1``:]` `            ``# Check if the word is available``            ``# in the set``            ``if` `(search ``in` `s):``                ``check ``=` `1``                ``break` `        ``if` `(check):``            ``ans ``+``=` `1` `    ``return` `ans` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:` `    ``str` `=` `[``"ohr"``, ``"tm"``, ``"ek"``]``    ``str1 ``=` `[``"mat"``, ``"hr"``]` `    ``print``(solution(``str``, str1))` `    ``# This code is contributed by rakeshsahni`

## C#

 `// C# code to implement the above approach``using` `System;``using` `System.Collections.Generic;` `public` `class` `GFG{` `  ``// Function to find permutation``  ``static` `int` `solution(String[] sw,``                      ``String[]  tw)``  ``{``    ``HashSet s = ``new` `HashSet();``    ``for` `(``int` `i = 0; i < sw.Length; i++) {``      ``sw[i] = sort(sw[i]);``      ``s.Add(sw[i]);``    ``}``    ``int` `ans = 0;` `    ``// Loop to check how many String``    ``// can be formed``    ``for` `(``int` `i = 0; i < tw.Length; i++) {``      ``String test = tw[i];``      ``test = sort(test);` `      ``// To track the number``      ``// Of the words formed``      ``bool` `check = ``false``;` `      ``for` `(``int` `j = 0; j < test.Length; j++) {` `        ``// SubString from 0 to 'i'``        ``// and remove one alphabet``        ``// and append rest of the String``        ``String search``          ``= test.Substring(0, j)``          ``+ test.Substring(j + 1);` `        ``// Check if the word is available``        ``// in the set``        ``if` `(s.Contains(search)) {``          ``check = ``true``;``          ``break``;``        ``}``      ``}``      ``if` `(check)``        ``ans++;``    ``}``    ``return` `ans;``  ``}``  ``//Method to sort a string alphabetically``  ``static` `String sort(String inputString)``  ``{``    ` `    ``// convert input string to char array``    ``char` `[]tempArray = inputString.ToCharArray();` `    ``// sort tempArray``    ``Array.Sort(tempArray);` `    ``// return new sorted string``    ``return` `new` `String(tempArray);``  ``}``  ` `  ``// Driver Code``  ``public` `static` `void` `Main(String[] args)``  ``{``    ``String[] str = { ``"ohr"``, ``"tm"``, ``"ek"` `};``    ``String[]  str1 = { ``"mat"``, ``"hr"` `};` `    ``Console.Write(solution(str, str1));``  ``}``}` `// This code is contributed by 29AjayKumar`

## Javascript

 ``

Output

`1`

Time Complexity: O(N*M) where N and M are the size of SearchWord[] and FindWord[]
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up