Skip to content
Related Articles

Related Articles

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

View Discussion
Improve Article
Save Article
Like Article
  • 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[0] 
‘r’ can be appended to the “fo” to make “for” which matches the FindWord[1] 

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 <bits/stdc++.h>
using namespace std;
 
// Function to find permutation
int solution(vector<string>& sw,
             vector<string>& tw)
{
    unordered_set<string> 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<string> str = { "ohr", "tm", "ek" };
    vector<string> 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<String> 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<String> s = new HashSet<String>();
    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




<script>
 
// JavaScript code to implement the above approach
 
// Function to find permutation
function solution(sw,tw)
{
    let s = new Set();
    for (let i = 0; i < sw.length; i++) {
        sw[i] = sw[i].split("").sort().join("");
        s.add(sw[i]);
    }
    let ans = 0;
 
    // Loop to check how many string
    // can be formed
    for (let i = 0; i < tw.length; i++) {
        let test = tw[i];
        test = test.split("").sort().join("");
 
        // To track the number
        // Of the words formed
        let check = 0;
 
        for (let j = 0; j < test.length; j++) {
 
            // Substring from 0 to 'i'
            // and remove one alphabet
            // and append rest of the string
            let search = test.substring(0, j) + test.substring(j + 1);
 
            // Check if the word is available
            // in the set
            if (s.has(search)) {
                check = 1;
                break;
            }
        }
        if (check)
            ans++;
    }
    return ans;
}
 
// Driver Code
 
let str = [ "ohr", "tm", "ek" ];
let str1 = [ "mat", "hr" ];
 
document.write(solution(str, str1));
 
// This code is contributed by shinjanpatra
 
</script>

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
Recommended Articles
Page :

Start Your Coding Journey Now!