# Print all Strings from array A[] having all strings from array B[] as subsequence

Given two arrays A[] and B[] consisting of strings, the task is to print the strings from array A[] having all strings in B[] as a subsequence.
Examples:

Input: A[] = {“geeksforgeeks”, “mapple”, “twitter”, “table”, “Linkedin”}, B[] = {“e”, “l”}
Explanation: Both the strings “e” and “l” are subsets in “mapple”, “table”, “linkedin”.

Input: A[] = {“geeksforgeeks”, “topcoder”, “leetcode”}, B[] = {“geek”, “ee”}
Output: geeksforgeeks
Explanation: Each string in B[], {“geek”, “ee”} occurs in “geeksforgeeks” only.

Naive Approach:
The simplest approach to solve the problem is to traverse array A[] and for every string, check if all the strings in array B[] are present in it as a subsequence or not.

Time complexity: O(N2 * L), where length denotes the maximum length of a string in array A[]
Auxiliary Space: O(1)

Efficient Approach:
To optimize the above approach, follow the steps below:

• Initialize a matrix A_fre[][], in which A_fre[i] stores the frequency of each character in ith string.
• Initialize B_fre[] to store frequency of all characters in the strings in array B[].
• Traverse over array A[] and for every string, check if a character has more frequency in the strings of array B[] than in ith string in A[], i.e.

if A_fre[i][j] < B_fre[j], where
A_fre[i][j]: Frequency of the character with ASCII value (‘a’ + j) in ith string in A[]
B_fre[j]: Frequency of the character with ASCII value (‘a’ + j) in the strings of B[].

then that string has at least one string in B[] which is not its subsequence.

• If the above condition is not satisfied for all characters for any string in A[], print that string as an answer.
• After checking all strings in A[], if no string is found to be having all strings in B[] as its proper subset, print -1.

Below is the implementation of the above approach:

## C++

 `// C++ Program to implement the ` `// above approach ` `#include ` `using` `namespace` `std; ` ` `  `// Function to find strings from A[] ` `// having all strings in B[] as subsequence ` `void` `UniversalSubset(vector A, ` `                     ``vector B) ` `{ ` `    ``// Calculate respective sizes ` `    ``int` `n1 = A.size(); ` `    ``int` `n2 = B.size(); ` ` `  `    ``// Stores the answer ` `    ``vector res; ` ` `  `    ``// Stores the frequency of each ` `    ``// character in strings of A[] ` `    ``int` `A_fre[n1]; ` ` `  `    ``for` `(``int` `i = 0; i < n1; i++) { ` `        ``for` `(``int` `j = 0; j < 26; j++) ` `            ``A_fre[i][j] = 0; ` `    ``} ` ` `  `    ``// Compute the frequencies ` `    ``// of characters of all strings ` `    ``for` `(``int` `i = 0; i < n1; i++) { ` `        ``for` `(``int` `j = 0; j < A[i].size(); ` `             ``j++) { ` `            ``A_fre[i][A[i][j] - ``'a'``]++; ` `        ``} ` `    ``} ` ` `  `    ``// Stores the frequency of each ` `    ``// character in strings of B[] ` `    ``// each character of a string in B[] ` `    ``int` `B_fre = { 0 }; ` ` `  `    ``for` `(``int` `i = 0; i < n2; i++) { ` `        ``int` `arr = { 0 }; ` `        ``for` `(``int` `j = 0; j < B[i].size(); ` `             ``j++) { ` ` `  `            ``arr[B[i][j] - ``'a'``]++; ` `            ``B_fre[B[i][j] - ``'a'``] ` `                ``= max(B_fre[B[i][j] - ``'a'``], ` `                      ``arr[B[i][j] - ``'a'``]); ` `        ``} ` `    ``} ` ` `  `    ``for` `(``int` `i = 0; i < n1; i++) { ` `        ``int` `flag = 0; ` `        ``for` `(``int` `j = 0; j < 26; j++) { ` ` `  `            ``// If the frequency of a character ` `            ``// in B[] exceeds that in A[] ` `            ``if` `(A_fre[i][j] < B_fre[j]) { ` ` `  `                ``// A string exists in B[] which ` `                ``// is not a proper subset of A[i] ` `                ``flag = 1; ` `                ``break``; ` `            ``} ` `        ``} ` ` `  `        ``// If all strings in B[] are ` `        ``// proper subset of A[] ` `        ``if` `(flag == 0) ` `            ``// Push the string in ` `            ``// resultant vector ` `            ``res.push_back(A[i]); ` `    ``} ` ` `  `    ``// If any string is found ` `    ``if` `(res.size()) { ` ` `  `        ``// Print those strings ` `        ``for` `(``int` `i = 0; i < res.size(); ` `             ``i++) { ` `            ``for` `(``int` `j = 0; j < res[i].size(); ` `                 ``j++) ` `                ``cout << res[i][j]; ` `        ``} ` ` `  `        ``cout << ``" "``; ` `    ``} ` ` `  `    ``// Otherwise ` `    ``else` `        ``cout << ``"-1"``; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``vector A = { ``"geeksforgeeks"``, ` `                         ``"topcoder"``, ` `                         ``"leetcode"` `}; ` `    ``vector B = { ``"geek"``, ``"ee"` `}; ` ` `  `    ``UniversalSubset(A, B); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java program to implement  ` `// the above approach  ` `import` `java.util.*; ` ` `  `class` `GFG { ` `     `  `// Function to find strings from A[]  ` `// having all strings in B[] as subsequence  ` `static` `void` `UniversalSubset(List A,  ` `                            ``List B)  ` `{  ` `     `  `    ``// Calculate respective sizes  ` `    ``int` `n1 = A.size();  ` `    ``int` `n2 = B.size();  ` ` `  `    ``// Stores the answer  ` `    ``List res = ``new` `ArrayList<>();  ` ` `  `    ``// Stores the frequency of each  ` `    ``// character in strings of A[]  ` `    ``int``[][] A_fre = ``new` `int``[n1][``26``];  ` ` `  `    ``for``(``int` `i = ``0``; i < n1; i++) ` `    ``{  ` `        ``for``(``int` `j = ``0``; j < ``26``; j++)  ` `            ``A_fre[i][j] = ``0``;  ` `    ``}  ` ` `  `    ``// Compute the frequencies  ` `    ``// of characters of all strings  ` `    ``for``(``int` `i = ``0``; i < n1; i++) ` `    ``{  ` `        ``for``(``int` `j = ``0``; j < A.get(i).length(); j++)  ` `        ``{  ` `            ``A_fre[i][A.get(i).charAt(j) - ``'a'``]++;  ` `        ``}  ` `    ``}  ` ` `  `    ``// Stores the frequency of each  ` `    ``// character in strings of B[]  ` `    ``// each character of a string in B[]  ` `    ``int``[] B_fre = ``new` `int``[``26``];  ` ` `  `    ``for``(``int` `i = ``0``; i < n2; i++) ` `    ``{  ` `        ``int``[] arr = ``new` `int``[``26``] ;  ` `        ``for``(``int` `j = ``0``; j < B.get(i).length(); j++) ` `        ``{  ` `            ``arr[B.get(i).charAt(j) - ``'a'``]++;  ` `            ``B_fre[B.get(i).charAt(j) - ``'a'``] = Math.max( ` `            ``B_fre[B.get(i).charAt(j) - ``'a'``],  ` `              ``arr[B.get(i).charAt(j) - ``'a'``]);  ` `        ``}  ` `    ``}  ` ` `  `    ``for``(``int` `i = ``0``; i < n1; i++) ` `    ``{  ` `        ``int` `flag = ``0``;  ` `        ``for``(``int` `j = ``0``; j < ``26``; j++)  ` `        ``{  ` ` `  `            ``// If the frequency of a character  ` `            ``// in B[] exceeds that in A[]  ` `            ``if` `(A_fre[i][j] < B_fre[j]) ` `            ``{  ` `                 `  `                ``// A string exists in B[] which  ` `                ``// is not a proper subset of A[i]  ` `                ``flag = ``1``;  ` `                ``break``;  ` `            ``}  ` `        ``}  ` ` `  `        ``// If all strings in B[] are  ` `        ``// proper subset of A[]  ` `        ``if` `(flag == ``0``)  ` `         `  `            ``// Push the string in  ` `            ``// resultant vector  ` `            ``res.add(A.get(i));  ` `    ``}  ` ` `  `    ``// If any string is found  ` `    ``if` `(res.size() != ``0``) ` `    ``{  ` `         `  `        ``// Print those strings  ` `        ``for``(``int` `i = ``0``; i < res.size(); i++)  ` `        ``{  ` `            ``for``(``int` `j = ``0``;  ` `                    ``j < res.get(i).length(); ` `                    ``j++)  ` `            ``System.out.print(res.get(i).charAt(j));  ` `        ``}  ` `        ``System.out.print(``" "``);  ` `    ``}  ` ` `  `    ``// Otherwise  ` `    ``else` `    ``System.out.print(``"-1"``);  ` `} ` ` `  `// Driver code ` `public` `static` `void` `main (String[] args)  ` `{ ` `    ``List A = Arrays.asList(``"geeksforgeeks"``,  ` `                                   ``"topcoder"``,  ` `                                   ``"leetcode"``);  ` `    ``List B = Arrays.asList(``"geek"``, ``"ee"``);  ` `     `  `    ``UniversalSubset(A, B);  ` `} ` `} ` ` `  `// This code is contributed by offbeat `

## Python3

 `# Python3 program to implement ` `# the above approach ` ` `  `# Function to find strings from A[] ` `# having all strings in B[] as subsequence ` `def` `UniversalSubset(A, B): ` ` `  `    ``# Calculate respective sizes ` `    ``n1 ``=` `len``(A) ` `    ``n2 ``=` `len``(B) ` ` `  `    ``# Stores the answer ` `    ``res ``=` `[] ` ` `  `    ``# Stores the frequency of each ` `    ``# character in strings of A[] ` `    ``A_freq ``=` `[[``0` `for` `x ``in` `range``(``26``)] ` `                 ``for` `y ``in` `range``(n1)] ` ` `  `    ``# Compute the frequencies ` `    ``# of characters of all strings ` `    ``for` `i ``in` `range``(n1): ` `        ``for` `j ``in` `range``(``len``(A[i])): ` `            ``A_freq[i][``ord``(A[i][j]) ``-` `ord``(``'a'``)] ``+``=` `1` ` `  `    ``# Stores the frequency of each ` `    ``# character in strings of B[] ` `    ``# each character of a string in B[] ` `    ``B_freq ``=` `[``0``] ``*` `26` ` `  `    ``for` `i ``in` `range``(n2): ` `        ``arr ``=` `[``0``] ``*` `26` `         `  `        ``for` `j ``in` `range``(``len``(B[i])): ` `            ``arr[``ord``(B[i][j]) ``-` `ord``(``'a'``)] ``+``=` `1` `             `  `            ``B_freq[``ord``(B[i][j]) ``-` `ord``(``'a'``)] ``=` `max``( ` `            ``B_freq[``ord``(B[i][j]) ``-` `ord``(``'a'``)], ` `               ``arr[``ord``(B[i][j]) ``-` `ord``(``'a'``)]) ` ` `  `    ``for` `i ``in` `range``(n1): ` `        ``flag ``=` `0` `        ``for` `j ``in` `range``(``26``): ` ` `  `            ``# If the frequency of a character ` `            ``# in B[] exceeds that in A[] ` `            ``if``(A_freq[i][j] < B_freq[j]): ` ` `  `                ``# A string exists in B[] which ` `                ``# is not a proper subset of A[i] ` `                ``flag ``=` `1` `                ``break` ` `  `        ``# If all strings in B[] are ` `        ``# proper subset of A[] ` `        ``if``(flag ``=``=` `0``): ` `             `  `            ``# Push the string in ` `            ``# resultant vector ` `            ``res.append(A[i]) ` ` `  `    ``# If any string is found ` `    ``if``(``len``(res)): ` ` `  `        ``# Print those strings ` `        ``for` `i ``in` `range``(``len``(res)): ` `            ``for` `j ``in` `range``(``len``(res[i])): ` `                ``print``(res[i][j], end ``=` `"") ` ` `  `    ``# Otherwise  ` `    ``else``: ` `        ``print``(``-``1``, end ``=` `"") ` ` `  `# Driver code ` `if` `__name__ ``=``=` `'__main__'``: ` ` `  `    ``A ``=` `[ ``"geeksforgeeks"``, ``"topcoder"``,  ` `          ``"leetcode"` `] ` `    ``B ``=` `[ ``"geek"``, ``"ee"` `] ` ` `  `    ``UniversalSubset(A, B) ` ` `  `# This code is contributed by Shivam Singh `

## C#

 `// C# program to implement ` `// the above approach ` `using` `System; ` `using` `System.Collections.Generic; ` ` `  `class` `GFG{ ` ` `  `// Function to find strings from []A ` `// having all strings in []B as subsequence ` `static` `void` `UniversalSubset(List A, ` `                            ``List B) ` `{ ` `     `  `    ``// Calculate respective sizes ` `    ``int` `n1 = A.Count; ` `    ``int` `n2 = B.Count; ` ` `  `    ``// Stores the answer ` `    ``List res = ``new` `List(); ` ` `  `    ``// Stores the frequency of each ` `    ``// character in strings of []A ` `    ``int``[,] A_fre = ``new` `int``[n1, 26]; ` ` `  `    ``for``(``int` `i = 0; i < n1; i++) ` `    ``{ ` `        ``for``(``int` `j = 0; j < 26; j++) ` `            ``A_fre[i, j] = 0; ` `    ``} ` ` `  `    ``// Compute the frequencies ` `    ``// of characters of all strings ` `    ``for``(``int` `i = 0; i < n1; i++) ` `    ``{ ` `        ``for``(``int` `j = 0; j < A[i].Length; j++) ` `        ``{ ` `            ``A_fre[i, A[i][j] - ``'a'``]++; ` `        ``} ` `    ``} ` ` `  `    ``// Stores the frequency of each ` `    ``// character in strings of []B ` `    ``// each character of a string in []B ` `    ``int``[] B_fre = ``new` `int``; ` ` `  `    ``for``(``int` `i = 0; i < n2; i++) ` `    ``{ ` `        ``int``[] arr = ``new` `int``; ` `        ``for``(``int` `j = 0; j < B[i].Length; j++) ` `        ``{ ` `            ``arr[B[i][j] - ``'a'``]++; ` `            ``B_fre[B[i][j] - ``'a'``] = Math.Max( ` `                                   ``B_fre[B[i][j] - ``'a'``], ` `                                     ``arr[B[i][j] - ``'a'``]); ` `        ``} ` `    ``} ` ` `  `    ``for``(``int` `i = 0; i < n1; i++) ` `    ``{ ` `        ``int` `flag = 0; ` `        ``for``(``int` `j = 0; j < 26; j++)  ` `        ``{ ` `             `  `            ``// If the frequency of a character ` `            ``// in []B exceeds that in []A ` `            ``if` `(A_fre[i, j] < B_fre[j]) ` `            ``{ ` `                 `  `                ``// A string exists in []B which ` `                ``// is not a proper subset of A[i] ` `                ``flag = 1; ` `                ``break``; ` `            ``} ` `        ``} ` ` `  `        ``// If all strings in []B are ` `        ``// proper subset of []A ` `        ``if` `(flag == 0) ` ` `  `            ``// Push the string in ` `            ``// resultant vector ` `            ``res.Add(A[i]); ` `    ``} ` ` `  `    ``// If any string is found ` `    ``if` `(res.Count != 0) ` `    ``{ ` `         `  `        ``// Print those strings ` `        ``for``(``int` `i = 0; i < res.Count; i++) ` `        ``{ ` `            ``for``(``int` `j = 0; j < res[i].Length; j++) ` `                ``Console.Write(res[i][j]); ` `        ``} ` `        ``Console.Write(``" "``); ` `    ``} ` ` `  `    ``// Otherwise ` `    ``else` `        ``Console.Write(``"-1"``); ` `} ` ` `  `// Driver code ` `public` `static` `void` `Main(String[] args) ` `{ ` `    ``List A = ``new` `List(); ` `    ``A.Add(``"geeksforgeeks"``); ` `    ``A.Add(``"topcoder"``); ` `    ``A.Add(``"leetcode"``); ` `     `  `    ``List B = ``new` `List(); ` `    ``B.Add(``"geek"``); ` `    ``B.Add(``"ee"``); ` ` `  `    ``UniversalSubset(A, B); ` `} ` `} ` ` `  `// This code is contributed by amal kumar choubey`

Output:

```geeksforgeeks
```

Time Complexity: O(N * * L), where length denotes the maximum length of a string in array A[].
Auxiliary Space: 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.

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.