Skip to content
Related Articles

Related Articles

Number of strings in two array satisfy the given conditions

View Discussion
Improve Article
Save Article
Like Article
  • 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) 


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!