 GeeksforGeeks App
Open App Browser
Continue

# Number of strings in two array satisfy the given conditions

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

Brute Force Approach: This approach uses a nested loop to iterate through each string in arr1 and arr2, and checks if the first character of each string in arr1 matches the first character of the string in arr2.

Step by step algorithm:

1. Initialize an empty vector of integers called result to store the count of valid strings.
2. For each string str2 in arr2, do the following:
a. Initialize a counter variable called count to 0.
b. For each string str1 in arr1, do the following:
i. Check if the first character of str1 is equal to the first character of str2.
ii. If they are equal, iterate over each character c in str1, and check if it is present in str2 using the find() function.
iii. If all characters of str1 are present in str2, increment the count.
c. Add the final count to the result vector.
3. Return the result vector.

Below is the implementation of above approach:

## C++

 `#include ``#include ``#include ` `using` `namespace` `std;` `vector<``int``> count_strings(vector arr1, vector arr2) {``    ``vector<``int``> result;``    ``for` `(string str2 : arr2) {``        ``int` `count = 0;``        ``for` `(string str1 : arr1) {``            ``if` `(str1 == str2) {``                ``bool` `flag = ``true``;``                ``for` `(``char` `c : str1) {``                    ``if` `(str2.find(c) == string::npos) {``                        ``flag = ``false``;``                        ``break``;``                    ``}``                ``}``                ``if` `(flag) {``                    ``count++;``                ``}``            ``}``        ``}``        ``result.push_back(count);``    ``}``    ``return` `result;``}` `int` `main() {``    ``vector arr1 = {``"aaaa"``, ``"asas"``, ``"able"``, ``"ability"``, ``"actt"``, ``"actor"``, ``"access"``};``    ``vector arr2 = {``"aboveyz"``, ``"abrodyz"``, ``"absolute"``, ``"absoryz"``, ``"actresz"``, ``"gaswxyz"``};``    ``vector<``int``> result = count_strings(arr1, arr2);``    ``for` `(``int` `i : result) {``        ``cout << i << ``"\n"``;``    ``}``    ``return` `0;``}`

Output

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

Time Complexity: O(N^2)
Space Complexity: O(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