# 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][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].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[26] = { 0 };`   `    ``for` `(``int` `i = 0; i < n2; i++) {` `        ``int` `arr[26] = { 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``[26];`   `    ``for``(``int` `i = 0; i < n2; i++)` `    ``{` `        ``int``[] arr = ``new` `int``[26];` `        ``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`

## Javascript

 ``

Output:

`geeksforgeeks`

Time Complexity: O(N * * L), where length denotes the maximum length of a string in array A[].
Auxiliary Space: O(N)