Related Articles

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

• Last Updated : 19 May, 2021

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`

## Javascript

 ``
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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up