Skip to content
Related Articles

Related Articles

Improve Article

Number of strings in two array satisfy the given conditions

  • Last Updated : 23 Jul, 2021

Given two arrays of string arr1[] and arr2[]. For each string in arr2[](say str2), the task is to count numbers string in arr1[](say str1) which satisfy the below conditions:

  • The first characters of str1 and str2 must be equal.
  • String str2 must contain each character of string str1.

Examples:

Input: arr1[] = {“aaaa”, “asas”, “able”, “ability”, “actt”, “actor”, “access”}, arr2[] = {“aboveyz”, “abrodyz”, “absolute”, “absoryz”, “actresz”, “gaswxyz”} 
Output: 






Explanation: 
The following is the string in arr1[] which follows the given condition: 
1 valid word for “aboveyz” : “aaaa”. 
1 valid word for “abrodyz” : “aaaa”. 
3 valid words for “absolute” : “aaaa”, “asas”, “able”. 
2 valid words for “absoryz” : “aaaa”, “asas”. 
4 valid words for “actresz” : “aaaa”, “asas”, “actt”, “access”. 
There are no valid words for “gaswxyz” because none of the words in the list contains the letter ‘g’.

Input: arr1[] = {“abbg”, “able”, “absolute”, “abil”, “actresz”, “gaswxyz”}, arr2[] = {“abbgaaa”, “asas”, “able”, “ability”} 
Output: 



1

Approach: This problem can be solved using the concept of Bitmasking. Below are the steps:



  • Convert each string of the array arr1[] to its corresponding bitmask as shown below:
For string str = "abcd"
the corresponding bitmask conversion is:
characters | value 
    a          0
    b          1
    c          2
    d          3
As per the above characters value, the number is:
value = 20 + 21 + 23 + 24
value = 15.
so the string "abcd" represented as 15.
  • Note: While bitmasking each string if the frequency of characters is more than 1, then include the corresponding characters only once.
  • Store the frequency of each string in an unordered_map.
  • Similarly, convert each string in the arr2[] to the corresponding bitmask and do the following:
    • Instead of calculating all possible words corresponding to arr1[], use the bit operation to find the next valid bitmask using temp = (temp – 1)&val.
    • It produces the next bitmask pattern, reducing one char at a time by producing all possible combinations.
  • For each valid permutation, check if it validates the given two conditions and adds the corresponding frequency to the current string stored in an unordered_map to the result.

Below is the implementation of the above approach:

C++




// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
void findNumOfValidWords(vector<string>& w,
                         vector<string>& p)
{
    // To store the frequency of string
    // after bitmasking
    unordered_map<int, int> m;
 
    // To store result for each string
    // in arr2[]
    vector<int> res;
 
    // Traverse the arr1[] and bitmask each
    // string in it
    for (string& s : w) {
 
        int val = 0;
 
        // Bitmasking for each string s
        for (char c : s) {
            val = val | (1 << (c - 'a'));
        }
 
        // Update the frequency of string
        // with it's bitmasking value
        m[val]++;
    }
 
    // Traverse the arr2[]
    for (string& s : p) {
        int val = 0;
 
        // Bitmasking for each string s
        for (char c : s) {
            val = val | (1 << (c - 'a'));
        }
 
        int temp = val;
        int first = s[0] - 'a';
        int count = 0;
 
        while (temp != 0) {
 
            // Check if temp is present
            // in an unordered_map or not
            if (((temp >> first) & 1) == 1) {
                if (m.find(temp) != m.end()) {
                    count += m[temp];
                }
            }
 
            // Check for next set bit
            temp = (temp - 1) & val;
        }
 
        // Push the count for current
        // string in resultant array
        res.push_back(count);
    }
 
    // Print the count for each string
    for (auto& it : res) {
        cout << it << '\n';
    }
}
 
// Driver Code
int main()
{
    vector<string> arr1;
    arr1 = { "aaaa", "asas", "able",
             "ability", "actt",
             "actor", "access" };
 
    vector<string> arr2;
    arr2 = { "aboveyz", "abrodyz",
             "absolute", "absoryz",
             "actresz", "gaswxyz" };
 
    // Function call
    findNumOfValidWords(arr1, arr2);
    return 0;
}

Java




// Java program for
// the above approach
import java.util.*;
class GFG{
 
static void findNumOfValidWords(Vector<String> w,
                                Vector<String> p)
{
  // To store the frequency of String
  // after bitmasking
  HashMap<Integer,
          Integer> m = new HashMap<>();
 
  // To store result for
  // each string in arr2[]
  Vector<Integer> res = new Vector<>();
 
  // Traverse the arr1[] and
  // bitmask each string in it
  for (String s : w)
  {
    int val = 0;
 
    // Bitmasking for each String s
    for (char c : s.toCharArray())
    {
      val = val | (1 << (c - 'a'));
    }
 
    // Update the frequency of String
    // with it's bitmasking value
    if(m.containsKey(val))
      m.put(val, m.get(val) + 1);
    else
      m.put(val, 1);
  }
 
  // Traverse the arr2[]
  for (String s : p)
  {
    int val = 0;
 
    // Bitmasking for each String s
    for (char c : s.toCharArray())
    {
      val = val | (1 << (c - 'a'));
    }
 
    int temp = val;
    int first = s.charAt(0) - 'a';
    int count = 0;
 
    while (temp != 0)
    {
      // Check if temp is present
      // in an unordered_map or not
      if (((temp >> first) & 1) == 1)
      {
        if (m.containsKey(temp))
        {
          count += m.get(temp);
        }
      }
 
      // Check for next set bit
      temp = (temp - 1) & val;
    }
 
    // Push the count for current
    // String in resultant array
    res.add(count);
  }
 
  // Print the count for each String
  for (int it : res)
  {
    System.out.println(it);
  }
}
 
// Driver Code
public static void main(String[] args)
{
  Vector<String> arr1 = new Vector<>();
  arr1.add("aaaa"); arr1.add("asas");
  arr1.add("able"); arr1.add("ability");
  arr1.add("actt"); arr1.add("actor");
  arr1.add("access");
 
  Vector<String> arr2 = new Vector<>();
  arr2.add("aboveyz"); arr2.add("abrodyz");
  arr2.add("absolute"); arr2.add("absoryz");
  arr2.add("actresz"); arr2.add("gaswxyz");
 
  // Function call
  findNumOfValidWords(arr1, arr2);
}
}
 
// This code is contributed by Princi Singh

Python3




# Python3 program for the above approach
from collections import defaultdict
 
def findNumOfValidWords(w, p):
 
    # To store the frequency of string
    # after bitmasking
    m = defaultdict(int)
 
    # To store result for each string
    # in arr2[]
    res = []
 
    # Traverse the arr1[] and bitmask each
    # string in it
    for s in w:
        val = 0
 
        # Bitmasking for each string s
        for c in s:
            val = val | (1 << (ord(c) - ord('a')))
 
        # Update the frequency of string
        # with it's bitmasking value
        m[val] += 1
 
    # Traverse the arr2[]
    for s in p:
        val = 0
 
        # Bitmasking for each string s
        for c in s:
            val = val | (1 << (ord(c) - ord('a')))
 
        temp = val
        first = ord(s[0]) - ord('a')
        count = 0
         
        while (temp != 0):
 
            # Check if temp is present
            # in an unordered_map or not
            if (((temp >> first) & 1) == 1):
                if (temp in m):
                    count += m[temp]
 
            # Check for next set bit
            temp = (temp - 1) & val
 
        # Push the count for current
        # string in resultant array
        res.append(count)
     
    # Print the count for each string
    for it in res:
        print(it)
 
# Driver Code
if __name__ == "__main__":
 
    arr1 = [ "aaaa", "asas", "able",
             "ability", "actt",
             "actor", "access" ]
 
    arr2 = [ "aboveyz", "abrodyz",
             "absolute", "absoryz",
             "actresz", "gaswxyz" ]
 
    # Function call
    findNumOfValidWords(arr1, arr2)
 
# This code is contributed by chitranayal

C#




// C# program for
// the above approach
using System;
using System.Collections.Generic;
class GFG{
 
static void findNumOfValidWords(List<String> w,
                                List<String> p)
{
  // To store the frequency of String
  // after bitmasking
  Dictionary<int,
             int> m = new Dictionary<int,
                                     int>();
   
  // To store result for
  // each string in arr2[]
  List<int> res = new List<int>();
 
  // Traverse the arr1[] and
  // bitmask each string in it
  foreach (String s in w)
  {
    int val = 0;
 
    // Bitmasking for each String s
    foreach (char c in s.ToCharArray())
    {
      val = val | (1 << (c - 'a'));
    }
 
    // Update the frequency of String
    // with it's bitmasking value
    if(m.ContainsKey(val))
      m[val] = m[val] + 1;
    else
      m.Add(val, 1);
  }
 
  // Traverse the arr2[]
  foreach (String s in p)
  {
    int val = 0;
 
    // Bitmasking for each String s
    foreach (char c in s.ToCharArray())
    {
      val = val | (1 << (c - 'a'));
    }
 
    int temp = val;
    int first = s[0] - 'a';
    int count = 0;
 
    while (temp != 0)
    {
      // Check if temp is present
      // in an unordered_map or not
      if (((temp >> first) & 1) == 1)
      {
        if (m.ContainsKey(temp))
        {
          count += m[temp];
        }
      }
 
      // Check for next set bit
      temp = (temp - 1) & val;
    }
 
    // Push the count for current
    // String in resultant array
    res.Add(count);
  }
 
  // Print the count
  // for each String
  foreach (int it in res)
  {
    Console.WriteLine(it);
  }
}
 
// Driver Code
public static void Main(String[] args)
{
  List<String> arr1 = new List<String>();
  arr1.Add("aaaa"); arr1.Add("asas");
  arr1.Add("able"); arr1.Add("ability");
  arr1.Add("actt"); arr1.Add("actor");
  arr1.Add("access");
 
  List<String> arr2 = new List<String>();
  arr2.Add("aboveyz"); arr2.Add("abrodyz");
  arr2.Add("absolute"); arr2.Add("absoryz");
  arr2.Add("actresz"); arr2.Add("gaswxyz");
 
  // Function call
  findNumOfValidWords(arr1, arr2);
}
}
 
// This code is contributed by shikhasingrajput

Javascript




<script>
 
// Javascript program for the above approach
 
function findNumOfValidWords(w, p)
{
    // To store the frequency of string
    // after bitmasking
    var m = new Map();
 
    // To store result for each string
    // in arr2[]
    var res = [];
 
    // Traverse the arr1[] and bitmask each
    // string in it
    w.forEach(s => {
        var val = 0;
 
        // Bitmasking for each string s
        s.split('').forEach(c => {
            val = val | (1 << (c.charCodeAt(0) - 'a'.charCodeAt(0)));
        });
 
        // Update the frequency of string
        // with it's bitmasking value
        if(m.has(val))
            m.set(val, m.get(val)+1)
        else
            m.set(val, 1)
    });
 
    // Traverse the arr2[]
    p.forEach(s => {
        var val = 0;
        s.split('').forEach(c => {
            val = val | (1 << (c.charCodeAt(0) - 'a'.charCodeAt(0)));
        });
 
        var temp = val;
        var first = s[0].charCodeAt(0) - 'a'.charCodeAt(0);
        var count = 0;
 
        while (temp != 0) {
 
            // Check if temp is present
            // in an unordered_map or not
            if (((temp >> first) & 1) == 1) {
                if (m.has(temp)) {
                    count += m.get(temp);
                }
            }
 
            // Check for next set bit
            temp = (temp - 1) & val;
        }
 
        // Push the count for current
        // string in resultant array
        res.push(count);
    });
 
    // Print the count for each string
    res.forEach(it => {
         
        document.write( it + "<br>");
    });
}
 
// Driver Code
var arr1 = ["aaaa", "asas", "able",
         "ability", "actt",
         "actor", "access" ];
 
var arr2 = [ "aboveyz", "abrodyz",
         "absolute", "absoryz",
         "actresz", "gaswxyz" ];
// Function call
findNumOfValidWords(arr1, arr2);
 
</script>
Output: 
1
1
3
2
4
0

 

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

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