# Longest subsequence with at least one character appearing in every string

• Last Updated : 10 May, 2021

Given a string array arr[], the task is to find the longest sub-sequence of the array with at least one character appearing in all the strings. Note that all the strings contain only lowercase English alphabets.
Examples:

Input: str = {“ab”, “bc”, “de”}
Output:
{“ab”, “bc”} is the required sub-sequence
with ‘b’ as the common character.
Input: str = {“a”, “b”, “c”}
Output:

Approach: Create a count[] array such that count[0] will store the number of strings which contain ‘a’, count[1] will store the number of strings which contain ‘b’ and so on…
Now, it’s clear that the answer will be the maximum value from the count[] array. In order to update this array start traversing the string array and for every string, mark which characters are present in the current string in a hash[] array.
And after the traversal, for every character which is present in the current string update its count in the count[] array.
Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach``#include ``using` `namespace` `std;` `#define MAX 26` `// Function to return the length of the longest``// sub-sequence with at least one``// common character in every string``int` `largestSubSeq(string arr[], ``int` `n)``{` `    ``// count[0] will store the number of strings``    ``// which contain 'a', count[1] will store the``    ``// number of strings which contain 'b' and so on..``    ``int` `count[MAX] = { 0 };` `    ``// For every string``    ``for` `(``int` `i = 0; i < n; i++) {``        ``string str = arr[i];` `        ``// Hash array to set which character is``        ``// present in the current string``        ``bool` `hash[MAX] = { 0 };``        ``for` `(``int` `j = 0; j < str.length(); j++) {``            ``hash[str[j] - ``'a'``] = ``true``;``        ``}` `        ``for` `(``int` `j = 0; j < MAX; j++) {` `            ``// If current character appears in the``            ``// string then update its count``            ``if` `(hash[j])``                ``count[j]++;``        ``}``    ``}` `    ``return` `*(max_element(count, count + MAX));``}` `// Driver code``int` `main()``{``    ``string arr[] = { ``"ab"``, ``"bc"``, ``"de"` `};``    ``int` `n = ``sizeof``(arr) / ``sizeof``(string);` `    ``cout << largestSubSeq(arr, n);` `    ``return` `0;``}`

## Java

 `// Java implementation of the approach` `class` `GFG``{``        ` `    ``static` `int` `MAX = ``26``;``    ` `    ``// Function to return the length of the longest``    ``// sub-sequence with at least one``    ``// common character in every string``    ``static` `int` `largestSubSeq(String arr[], ``int` `n)``    ``{``    ` `        ``// count[0] will store the number of strings``        ``// which contain 'a', count[1] will store the``        ``// number of strings which contain 'b' and so on..``        ``int` `[] count = ``new` `int``[MAX];``    ` `        ``// For every string``        ``for` `(``int` `i = ``0``; i < n; i++) {``            ``String str = arr[i];``    ` `            ``// Hash array to set which character is``            ``// present in the current string``            ``boolean` `[] hash = ``new` `boolean``[MAX];``            ` `            ` `            ``for` `(``int` `j = ``0``; j < str.length(); j++) {``                ``hash[str.charAt(j) - ``'a'``] = ``true``;``            ``}``    ` `            ``for` `(``int` `j = ``0``; j < MAX; j++) {``    ` `                ``// If current character appears in the``                ``// string then update its count``                ``if` `(hash[j])``                    ``count[j]++;``            ``}``        ``}``        ` `        ``int` `max = -``1``;``    ` `        ``for``(``int` `i=``0``;i< MAX; i++)``        ``{``            ``if``(max < count[i])``                ``max = count[i];``        ``}``        ``return` `max;``    ``}``    ` `    ``// Driver code``    ``public` `static` `void` `main (String[] args)``    ``{``        ` `        ``String arr[] = { ``"ab"``, ``"bc"``, ``"de"` `};``        ``int` `n = arr.length;``    ` `        ``System.out.println(largestSubSeq(arr, n));``    `  `    ``}`  `}` `// This code is contributed by ihritik`

## Python3

 `# Python3 implementation of the approach``MAX` `=` `26` `# Function to return the length of the longest``# sub-sequence with at least one``# common character in every string``def` `largestSubSeq(arr, n):``    ` `    ``# count[0] will store the number of strings``    ``# which contain 'a', count[1] will store the``    ``# number of strings which contain 'b' and so on..``    ``count ``=` `[``0``] ``*` `MAX``    ` `    ``# For every string``    ``for` `i ``in` `range``(n):``        ``string ``=` `arr[i]``        ` `        ``# Hash array to set which character is``        ``# present in the current string``        ``_hash ``=` `[``False``] ``*` `MAX``        ``for` `j ``in` `range``(``len``(string)):``            ``_hash[``ord``(string[j]) ``-` `ord``(``'a'``)] ``=` `True``        ` `        ``for` `j ``in` `range``(``MAX``):``            ` `            ``# If current character appears in the``            ``# string then update its count``            ``if` `_hash[j] ``=``=` `True``:``                ``count[j] ``+``=` `1``                ` `    ``return` `max``(count)` `# Driver code``if` `__name__ ``=``=` `"__main__"``:``    ``arr ``=` `[ ``"ab"``, ``"bc"``, ``"de"` `]``    ``n ``=` `len``(arr)``    ``print``(largestSubSeq(arr, n))` `# This code is contributed by``# sanjeev2552`

## C#

 `// C# implementation of the approach``using` `System;` `class` `GFG``{``        ` `    ``static` `int` `MAX = 26;``    ` `    ``// Function to return the length of the longest``    ``// sub-sequence with at least one``    ``// common character in every string``    ``static` `int` `largestSubSeq(``string` `[] arr, ``int` `n)``    ``{``    ` `        ``// count[0] will store the number of strings``        ``// which contain 'a', count[1] will store the``        ``// number of strings which contain 'b' and so on..``        ``int` `[] count = ``new` `int``[MAX];``    ` `        ``// For every string``        ``for` `(``int` `i = 0; i < n; i++)``        ``{``            ``string` `str = arr[i];``    ` `            ``// Hash array to set which character is``            ``// present in the current string``            ``bool` `[] hash = ``new` `bool``[MAX];``            ` `            ` `            ``for` `(``int` `j = 0; j < str.Length; j++)``            ``{``                ``hash[str[j] - ``'a'``] = ``true``;``            ``}``    ` `            ``for` `(``int` `j = 0; j < MAX; j++)``            ``{``    ` `                ``// If current character appears in the``                ``// string then update its count``                ``if` `(hash[j])``                    ``count[j]++;``            ``}``        ``}``        ` `        ``int` `max = -1;``    ` `        ``for``(``int` `i=0;i< MAX; i++)``        ``{``            ``if``(max < count[i])``                ``max = count[i];``        ``}``        ``return` `max;``    ``}``    ` `    ``// Driver code``    ``public` `static` `void` `Main ()``    ``{``        ` `        ``string` `[] arr = { ``"ab"``, ``"bc"``, ``"de"` `};``        ``int` `n = arr.Length;``    ` `        ``Console.WriteLine(largestSubSeq(arr, n));``    ``}``}` `// This code is contributed by ihritik`

## Javascript

 ``
Output:
`2`

My Personal Notes arrow_drop_up