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

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)