Given an array. The task is to find the length of the longest subsequence in which all elements must have at least one digit in common.

**Examples:**

Input: arr[] = { 11, 12, 23, 74, 13 }Output: 3Explanation: The elements 11, 12, and 13 have the digit ‘1’ as common. So it is the required longest sub-sequence.

Input: arr[] = { 12, 90, 67, 78, 45 }Output: 2

**Normal Approach:** Find all the subsequences of the array and find the subsequence in which every element must have a common digit. Then we have to find the longest such subsequence and print the length of that subsequence. This method will take exponential time complexity.

**Efficient Approach:** The idea is to take a hash array of size 10 to store the count of digits from 0-9 appearing in the elements of the array. Traverse the array and for every element of the array, find the unique digits in that element and increment their count in the hash array. Now, the digit with the maximum count in the hash array indicates that it is the maximum occurring common digit among the elements of the array. So, the length of the required longest subsequence will be the count of maximum in the hash array.

Let us take an example,

Let the array be arr[] = {11, 12, 13, 24}

Initially the count array is { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }

1st element is 11 so digits are 1 and 1 (but 1 will be counted once}

count array is { 0, 1, 0, 0, 0, 0, 0, 0, 0, 0 }2nd element is 12 so digits are 1, 2

count array is { 0, 2, 1, 0, 0, 0, 0, 0, 0, 0 }3rd element is 13 so digits are 1, 3

count array is { 0, 3, 1, 1, 0, 0, 0, 0, 0, 0 }4th element is 24 so digits are 2, 4

count array is { 0, 3, 2, 1, 1, 0, 0, 0, 0, 0 }So the maximum value in count array is 3

Therefore, 3 will be the answer

Below is the implementation of the above approach:

`// C++ program to find the length of subsequence which has ` `// atleast one digit common among all its elements ` `#include <bits/stdc++.h> ` `using` `namespace` `std; `
` ` `// If the number contains a digit increase ` `// the count by 1 (even if it has multiple ` `// same digit the count should be increased ` `// by only once) ` `void` `count_(` `int` `count[], ` `int` `e) `
`{ ` ` ` `// Hash to make it sure that a digit `
` ` `// is counted only once `
` ` `bool` `hash[10]; `
` ` ` ` `// Set the hash to its initial value `
` ` `memset` `(hash, ` `false` `, ` `sizeof` `(hash)); `
` ` ` ` `// Extract the digits `
` ` `while` `(e > 0) { `
` ` ` ` `// If the digit did not appear before `
` ` `if` `(hash[e % 10] == ` `false` `) `
` ` ` ` `// Increase the count `
` ` `count[e % 10]++; `
` ` ` ` `// Mark the digit as visited `
` ` `hash[e % 10] = ` `true` `; `
` ` ` ` `// Delete the digit `
` ` `e /= 10; `
` ` `} `
`} ` ` ` `// Function to find the length of subsequence which has ` `// atleast one digit common among all its elements ` `void` `find_subsequence(` `int` `arr[], ` `int` `n) `
`{ ` ` ` `// Count of digits `
` ` `int` `count[10]; `
` ` ` ` `// Set the initial value to zero `
` ` `memset` `(count, 0, ` `sizeof` `(count)); `
` ` `for` `(` `int` `i = 0; i < n; i++) { `
` ` ` ` `// Extract the digits of the element `
` ` `// and increase the count `
` ` `count_(count, arr[i]); `
` ` `} `
` ` ` ` `// Longest subsequence `
` ` `int` `longest = 0; `
` ` ` ` `// Get the longest subsequence `
` ` `for` `(` `int` `i = 0; i < 10; i++) `
` ` `longest = max(count[i], longest); `
` ` ` ` `// Print the length of longest subsequence `
` ` `cout << longest << endl; `
`} ` ` ` `// Driver code ` `int` `main() `
`{ ` ` ` `int` `arr[] = { 11, 12, 23, 74, 13 }; `
` ` ` ` `int` `n = ` `sizeof` `(arr) / ` `sizeof` `(arr[0]); `
` ` ` ` `find_subsequence(arr, n); `
` ` ` ` `return` `0; `
`} ` |

*chevron_right*

*filter_none*

`// Java program to find the length of subsequence which has ` `// atleast one digit common among all its elements ` ` ` `import` `java.io.*; `
` ` `class` `GFG { `
` ` `// If the number contains a digit increase ` `// the count by 1 (even if it has multiple ` `// same digit the count should be increased ` `// by only once) ` `static` `void` `count_(` `int` `count[], ` `int` `e) `
`{ ` ` ` `// Hash to make it sure that a digit `
` ` `// is counted only once `
` ` `boolean` `hash[] = ` `new` `boolean` `[` `10` `]; `
` ` ` ` `// Set the hash to its initial value `
` ` `//memset(hash, false, sizeof(hash)); `
` ` ` ` `// Extract the digits `
` ` `while` `(e > ` `0` `) { `
` ` ` ` `// If the digit did not appear before `
` ` `if` `(hash[e % ` `10` `] == ` `false` `) `
` ` ` ` `// Increase the count `
` ` `count[e % ` `10` `]++; `
` ` ` ` `// Mark the digit as visited `
` ` `hash[e % ` `10` `] = ` `true` `; `
` ` ` ` `// Delete the digit `
` ` `e /= ` `10` `; `
` ` `} `
`} ` ` ` `// Function to find the length of subsequence which has ` `// atleast one digit common among all its elements ` `static` `void` `find_subsequence(` `int` `arr[], ` `int` `n) `
`{ ` ` ` `// Count of digits `
` ` `int` `count[] = ` `new` `int` `[` `10` `]; `
` ` ` ` `// Set the initial value to zero `
` ` `//memset(count, 0, sizeof(count)); `
` ` `for` `(` `int` `i = ` `0` `; i < n; i++) { `
` ` ` ` `// Extract the digits of the element `
` ` `// and increase the count `
` ` `count_(count, arr[i]); `
` ` `} `
` ` ` ` `// Longest subsequence `
` ` `int` `longest = ` `0` `; `
` ` ` ` `// Get the longest subsequence `
` ` `for` `(` `int` `i = ` `0` `; i < ` `10` `; i++) `
` ` `longest = Math.max(count[i], longest); `
` ` ` ` `// Print the length of longest subsequence `
` ` `System.out.print( longest); `
`} ` ` ` ` ` `// Driver code `
` ` `public` `static` `void` `main (String[] args) { `
` ` `int` `arr[] = { ` `11` `, ` `12` `, ` `23` `, ` `74` `, ` `13` `}; `
` ` ` ` `int` `n =arr.length; `
` ` ` ` `find_subsequence(arr, n); `
` ` ` ` `} `
`} ` `// This code is contributed ` `// by shs ` |

*chevron_right*

*filter_none*

`# Python3 program to find the length ` `# of subsequence which has atleast ` `# one digit common among all its elements ` ` ` `# If the number contains a digit increase ` `# the count by 1 (even if it has multiple ` `# same digit the count should be increased ` `# by only once) ` `def` `count_(count, e): `
` ` ` ` `# Hash to make it sure that a digit `
` ` `# is counted only once `
` ` `hash` `=` `[` `False` `] ` `*` `10`
` ` ` ` `# Extract the digits `
` ` `while` `(e > ` `0` `): `
` ` ` ` `# If the digit did not `
` ` `# appear before `
` ` `if` `(` `hash` `[e ` `%` `10` `] ` `=` `=` `False` `) : `
` ` ` ` `# Increase the count `
` ` `count[e ` `%` `10` `] ` `+` `=` `1`
` ` ` ` `# Mark the digit as visited `
` ` `hash` `[e ` `%` `10` `] ` `=` `True`
` ` ` ` `# Delete the digit `
` ` `e ` `/` `/` `=` `10`
` ` `# Function to find the length of ` `# subsequence which has atleast ` `# one digit common among all its elements ` `def` `find_subsequence(arr, n) : `
` ` ` ` `# Count of digits `
` ` `count ` `=` `[` `0` `] ` `*` `10`
` ` ` ` `for` `i ` `in` `range` `( n) : `
` ` ` ` `# Extract the digits of the element `
` ` `# and increase the count `
` ` `count_(count, arr[i]) `
` ` ` ` `# Longest subsequence `
` ` `longest ` `=` `0`
` ` ` ` `# Get the longest subsequence `
` ` `for` `i ` `in` `range` `(` `10` `) : `
` ` `longest ` `=` `max` `(count[i], longest) `
` ` ` ` `# Print the length of `
` ` `# longest subsequence `
` ` `print` `(longest) `
` ` `# Driver code ` `if` `__name__ ` `=` `=` `"__main__"` `: `
` ` ` ` `arr ` `=` `[ ` `11` `, ` `12` `, ` `23` `, ` `74` `, ` `13` `] `
` ` ` ` `n ` `=` `len` `(arr) `
` ` ` ` `find_subsequence(arr, n) `
` ` `# This code is contributed ` `# by ChitraNayal ` |

*chevron_right*

*filter_none*

`// C# program to find the length ` `// of subsequence which has atleast ` `// one digit common among all its elements ` `using` `System; `
` ` `class` `GFG `
`{ ` ` ` `// If the number contains a digit increase ` `// the count by 1 (even if it has multiple ` `// same digit the count should be increased ` `// by only once) ` `static` `void` `count_(` `int` `[]count, ` `int` `e) `
`{ ` ` ` `// Hash to make it sure that a `
` ` `// digit is counted only once `
` ` `bool` `[]hash = ` `new` `bool` `[10]; `
` ` ` ` `// Set the hash to its initial value `
` ` `//memset(hash, false, sizeof(hash)); `
` ` ` ` `// Extract the digits `
` ` `while` `(e > 0) `
` ` `{ `
` ` ` ` `// If the digit did not `
` ` `// appear before `
` ` `if` `(hash[e % 10] == ` `false` `) `
` ` ` ` `// Increase the count `
` ` `count[e % 10]++; `
` ` ` ` `// Mark the digit as visited `
` ` `hash[e % 10] = ` `true` `; `
` ` ` ` `// Delete the digit `
` ` `e /= 10; `
` ` `} `
`} ` ` ` `// Function to find the length of ` `// subsequence which has atleast ` `// one digit common among all its elements ` `static` `void` `find_subsequence(` `int` `[]arr, `
` ` `int` `n) `
`{ ` ` ` `// Count of digits `
` ` `int` `[]count = ` `new` `int` `[10]; `
` ` ` ` `// Set the initial value to zero `
` ` `//memset(count, 0, sizeof(count)); `
` ` `for` `(` `int` `i = 0; i < n; i++) `
` ` `{ `
` ` ` ` `// Extract the digits of the element `
` ` `// and increase the count `
` ` `count_(count, arr[i]); `
` ` `} `
` ` ` ` `// Longest subsequence `
` ` `int` `longest = 0; `
` ` ` ` `// Get the longest subsequence `
` ` `for` `(` `int` `i = 0; i < 10; i++) `
` ` `longest = Math.Max(count[i], longest); `
` ` ` ` `// Print the length of `
` ` `// longest subsequence `
` ` `Console.WriteLine(longest); `
`} ` ` ` `// Driver code ` `public` `static` `void` `Main () `
`{ ` ` ` `int` `[]arr = { 11, 12, 23, 74, 13 }; `
` ` ` ` `int` `n = arr.Length; `
` ` ` ` `find_subsequence(arr, n); `
`} ` `} ` ` ` `// This code is contributed ` `// by Shashank ` |

*chevron_right*

*filter_none*

**Output:**

3

## Recommended Posts:

- Longest subsequence such that adjacent elements have at least one common digit
- Longest subarray such that adjacent elements have at least one common digit | Set 1
- Longest subarray such that adjacent elements have at least one common digit | Set - 2
- Longest subsequence with at least one character appearing in every string
- Longest subsequence such that every element in the subsequence is formed by multiplying previous element with a prime
- Longest Increasing Subsequence using Longest Common Subsequence Algorithm
- Count pairs in an array which have at least one digit common
- Minimum sum subsequence such that at least one of every four consecutive elements is picked
- Replace every element with the least greater element on its right
- Minimize length of Substrings containing at least one common Character
- Lexicographically largest subsequence such that every character occurs at least k times
- Maximum length subsequence such that adjacent elements in the subsequence have a common factor
- Longest subsequence where each character occurs at least k times
- Minimum number of towers required such that every house is in the range of at least one tower
- Minimum bit flips such that every K consecutive bits contain at least one set bit
- Convert a number of length N such that it contains any one digit at least 'K' times
- Longest Common Subsequence | DP-4
- Printing Longest Common Subsequence
- Longest Common Increasing Subsequence (LCS + LIS)
- Printing Longest Common Subsequence | Set 2 (Printing All)

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.

**Article Tags :**