# 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"
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 ``using` `namespace` `std;` `void` `findNumOfValidWords(vector& w,``                         ``vector& 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 - ``'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 arr1;``    ``arr1 = { ``"aaaa"``, ``"asas"``, ``"able"``,``             ``"ability"``, ``"actt"``,``             ``"actor"``, ``"access"` `};` `    ``vector 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 w,``                                ``Vector p)``{``  ``// To store the frequency of String``  ``// after bitmasking``  ``HashMap m = ``new` `HashMap<>();` `  ``// To store result for``  ``// each string in arr2[]``  ``Vector 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 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 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 w,``                                ``List 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 - ``'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 arr1 = ``new` `List();``  ``arr1.Add(``"aaaa"``); arr1.Add(``"asas"``);``  ``arr1.Add(``"able"``); arr1.Add(``"ability"``);``  ``arr1.Add(``"actt"``); arr1.Add(``"actor"``);``  ``arr1.Add(``"access"``);` `  ``List arr2 = ``new` `List();``  ``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

 ``

Output:

```1
1
3
2
4
0```

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

My Personal Notes arrow_drop_up