Count of subsequence of an Array having all unique digits
Last Updated :
30 Nov, 2021
Given an array A containing N positive integers, the task is to find the number of subsequences of this array such that in each subsequence , no digit is repeated twice, i.e. all the digits of the subsequences must be unique.
Examples:
Input: A = [1, 12, 23, 34]
Output: 7
The subsequences are: {1}, {12}, {23}, {34}, {1, 23}, {1, 34}, {12, 34}
Therefore the count of such subsequences = 7
Input: A = [5, 12, 2, 1, 165, 2323, 7]
Output: 33
Naive approach: Generate all subsequences of the array and traverse through them to check whether the given condition is satisfied or not. Print the count of such subsequences at the end.
Below is the implementation of the above approach:
C++
// C++ program to find the count
// of subsequences of an Array
// having all unique digits
#include <bits/stdc++.h>
using namespace std;
// Function to check whether
// the subsequences has all unique digits
bool check(vector<int>& v)
{
// Storing all digits occurred
set<int> digits;
// Traversing all the numbers of v
for (int i = 0; i < v.size(); i++) {
// Storing all digits of v[i]
set<int> d;
while (v[i]) {
d.insert(v[i] % 10);
v[i] /= 10;
}
// Checking whether digits of v[i]
// have already occurred
for (auto it : d) {
if (digits.count(it))
return false;
}
// Inserting digits of v[i] in the set
for (auto it : d)
digits.insert(it);
}
return true;
}
// Function to count the number
// subarray with all digits unique
int numberOfSubarrays(int a[], int n)
{
int answer = 0;
// Traverse through all the subarrays
for (int i = 1; i < (1 << n); i++) {
// To store elements of this subarray
vector<int> temp;
// Generate all subarray
// and store it in vector
for (int j = 0; j < n; j++) {
if (i & (1 << j))
temp.push_back(a[j]);
}
// Check whether this subarray
// has all digits unique
if (check(temp))
// Increase the count
answer++;
}
// Return the count
return answer;
}
// Driver code
int main()
{
int N = 4;
int A[] = { 1, 12, 23, 34 };
cout << numberOfSubarrays(A, N);
return 0;
}
// Java program to find the count
// of subarrays of an Array
// having all unique digits
import java.util.*;
class GFG{
// Function to check whether
// the subarray has all unique digits
static boolean check(Vector<Integer> v)
{
// Storing all digits occurred
HashSet<Integer> digits = new HashSet<Integer>();
// Traversing all the numbers of v
for (int i = 0; i < v.size(); i++) {
// Storing all digits of v[i]
HashSet<Integer> d = new HashSet<Integer>();
while (v.get(i)>0) {
d.add(v.get(i) % 10);
v.set(i, v.get(i)/10);
}
// Checking whether digits of v[i]
// have already occurred
for (int it : d) {
if (digits.contains(it))
return false;
}
// Inserting digits of v[i] in the set
for (int it : d)
digits.add(it);
}
return true;
}
// Function to count the number
// subarray with all digits unique
static int numberOfSubarrays(int a[], int n)
{
int answer = 0;
// Traverse through all the subarrays
for (int i = 1; i < (1 << n); i++) {
// To store elements of this subarray
Vector<Integer> temp = new Vector<Integer>();
// Generate all subarray
// and store it in vector
for (int j = 0; j < n; j++) {
if ((i & (1 << j))>0)
temp.add(a[j]);
}
// Check whether this subarray
// has all digits unique
if (check(temp))
// Increase the count
answer++;
}
// Return the count
return answer;
}
// Driver code
public static void main(String[] args)
{
int N = 4;
int A[] = { 1, 12, 23, 34 };
System.out.print(numberOfSubarrays(A, N));
}
}
// This code is contributed by 29AjayKumar
# Python3 program to find the count
# of subarrays of an Array
# having all unique digits
# Function to check whether
# the subarray has all unique digits
def check(v):
# Storing all digits occurred
digits = set()
# Traversing all the numbers of v
for i in range(len(v)):
# Storing all digits of v[i]
d = set()
while (v[i] != 0):
d.add(v[i] % 10)
v[i] //= 10
# Checking whether digits of v[i]
# have already occurred
for it in d:
if it in digits:
return False
# Inserting digits of v[i] in the set
for it in d:
digits.add(it)
return True
# Function to count the number
# subarray with all digits unique
def numberOfSubarrays(a, n):
answer = 0
# Traverse through all the subarrays
for i in range(1, 1 << n):
# To store elements of this subarray
temp = []
# Generate all subarray
# and store it in vector
for j in range(n):
if (i & (1 << j)):
temp.append(a[j])
# Check whether this subarray
# has all digits unique
if (check(temp)):
# Increase the count
answer += 1
# Return the count
return answer
# Driver code
if __name__=="__main__":
N = 4
A = [ 1, 12, 23, 34 ]
print(numberOfSubarrays(A, N))
# This code is contributed by rutvik_56
// C# program to find the count
// of subarrays of an Array
// having all unique digits
using System;
using System.Collections.Generic;
class GFG{
// Function to check whether
// the subarray has all unique digits
static bool check(List<int> v)
{
// Storing all digits occurred
HashSet<int> digits = new HashSet<int>();
// Traversing all the numbers of v
for(int i = 0; i < v.Count; i++)
{
// Storing all digits of v[i]
HashSet<int> d = new HashSet<int>();
while (v[i] > 0)
{
d.Add(v[i] % 10);
v[i] = v[i] / 10;
}
// Checking whether digits of v[i]
// have already occurred
foreach(int it in d)
{
if (digits.Contains(it))
return false;
}
// Inserting digits of v[i] in the set
foreach(int it in d)
digits.Add(it);
}
return true;
}
// Function to count the number
// subarray with all digits unique
static int numberOfSubarrays(int []a, int n)
{
int answer = 0;
// Traverse through all the subarrays
for(int i = 1; i < (1 << n); i++)
{
// To store elements of this subarray
List<int> temp = new List<int>();
// Generate all subarray
// and store it in vector
for(int j = 0; j < n; j++)
{
if ((i & (1 << j)) > 0)
temp.Add(a[j]);
}
// Check whether this subarray
// has all digits unique
if (check(temp))
// Increase the count
answer++;
}
// Return the count
return answer;
}
// Driver code
public static void Main(String[] args)
{
int N = 4;
int []A = { 1, 12, 23, 34 };
Console.Write(numberOfSubarrays(A, N));
}
}
// This code is contributed by sapnasingh4991
<script>
// Javascript program to find the count
// of subarrays of an Array
// having all unique digits
// Function to check whether
// the subarray has all unique digits
function check(v) {
// Storing all digits occurred
let digits = new Set();
// Traversing all the numbers of v
for (let i = 0; i < v.length; i++) {
// Storing all digits of v[i]
let d = new Set();
while (v[i]) {
d.add(v[i] % 10);
v[i] = Math.floor(v[i] / 10);
}
// Checking whether digits of v[i]
// have already occurred
for (let it of d) {
if (digits.has(it))
return false;
}
// Inserting digits of v[i] in the set
for (let it of d)
digits.add(it);
}
return true;
}
// Function to count the number
// subarray with all digits unique
function numberOfSubarrays(a, n) {
let answer = 0;
// Traverse through all the subarrays
for (let i = 1; i < (1 << n); i++) {
// To store elements of this subarray
let temp = new Array();
// Generate all subarray
// and store it in vector
for (let j = 0; j < n; j++) {
if (i & (1 << j))
temp.push(a[j]);
}
// Check whether this subarray
// has all digits unique
if (check(temp))
// Increase the count
answer++;
}
// Return the count
return answer;
}
// Driver code
let N = 4;
let A = [1, 12, 23, 34];
document.write(numberOfSubarrays(A, N));
// This code is contributed by gfgking
</script>
Time Complexity: O(N * 2N)
Efficient Approach: This approach depends upon the fact that there exist only 10 unique digits in the Decimal number system. Therefore the longest subsequence will have only 10 digits in it, to meet the required condition.
- We will use Bitmasking and Dynamic Programming to solve the problem.
- Since there are only 10 digits, consider a 10-bit representation of every number where each bit is 1 if digit corresponding to that bit is present in that number.
- Let, i be the current array element (elements from 1 to i-1 are already processed). An integer variable 'mask' indicates the digits which have already occurred in the subsequence. If i'th bit is set in the mask, then i'th digit has occurred, else not.
- At each step of recurrence relation, the element can either be included in the subsequence or not. If the element is not included in the subarray, then simply move to the next index. If it is included, change the mask by setting all the bits corresponding to the current element's digit, ON in the mask.
Note: The current element can only be included if all of its digits have not occurred previously. - This condition will be satisfied only if the bits corresponding to the current element's digits in the mask are OFF.
- If we draw the complete recursion tree, we can observe that many subproblems are being solved again and again. So we use Dynamic Programming. A table dp[][] is used such that for every index dp[i][j], i is the position of the element in the array and j is the mask.
Below is the implementation of the above approach:
C++
// C++ program to find the count
// of subsequences of an Array
// having all unique digits
#include <bits/stdc++.h>
using namespace std;
// Dynamic programming table
int dp[5000][(1 << 10) + 5];
// Function to obtain
// the mask for any integer
int getmask(int val)
{
int mask = 0;
if (val == 0)
return 1;
while (val) {
int d = val % 10;
mask |= (1 << d);
val /= 10;
}
return mask;
}
// Function to count the number of ways
int countWays(int pos, int mask,
int a[], int n)
{
// Subarray must not be empty
if (pos == n)
return (mask > 0 ? 1 : 0);
// If subproblem has been solved
if (dp[pos][mask] != -1)
return dp[pos][mask];
int count = 0;
// Excluding this element in the subarray
count = count
+ countWays(pos + 1, mask, a, n);
// If there are no common digits
// then only this element can be included
if ((getmask(a[pos]) & mask) == 0) {
// Calculate the new mask
// if this element is included
int new_mask
= (mask | (getmask(a[pos])));
count = count
+ countWays(pos + 1,
new_mask,
a, n);
}
// Store and return the answer
return dp[pos][mask] = count;
}
// Function to find the count of
// subarray with all digits unique
int numberOfSubarrays(int a[], int n)
{
// initializing dp
memset(dp, -1, sizeof(dp));
return countWays(0, 0, a, n);
}
// Driver code
int main()
{
int N = 4;
int A[] = { 1, 12, 23, 34 };
cout << numberOfSubarrays(A, N);
return 0;
}
// Java program to find the count
// of subarrays of an Array
// having all unique digits
import java.util.*;
class GFG{
// Dynamic programming table
static int [][]dp = new int[5000][(1 << 10) + 5];
// Function to obtain
// the mask for any integer
static int getmask(int val)
{
int mask = 0;
if (val == 0)
return 1;
while (val > 0) {
int d = val % 10;
mask |= (1 << d);
val /= 10;
}
return mask;
}
// Function to count the number of ways
static int countWays(int pos, int mask,
int a[], int n)
{
// Subarray must not be empty
if (pos == n)
return (mask > 0 ? 1 : 0);
// If subproblem has been solved
if (dp[pos][mask] != -1)
return dp[pos][mask];
int count = 0;
// Excluding this element in the subarray
count = count
+ countWays(pos + 1, mask, a, n);
// If there are no common digits
// then only this element can be included
if ((getmask(a[pos]) & mask) == 0) {
// Calculate the new mask
// if this element is included
int new_mask
= (mask | (getmask(a[pos])));
count = count
+ countWays(pos + 1,
new_mask,
a, n);
}
// Store and return the answer
return dp[pos][mask] = count;
}
// Function to find the count of
// subarray with all digits unique
static int numberOfSubarrays(int a[], int n)
{
// initializing dp
for(int i = 0;i<5000;i++)
{
for (int j = 0; j < (1 << 10) + 5; j++) {
dp[i][j] = -1;
}
}
return countWays(0, 0, a, n);
}
// Driver code
public static void main(String[] args)
{
int N = 4;
int A[] = { 1, 12, 23, 34 };
System.out.print(numberOfSubarrays(A, N));
}
}
// This code is contributed by Princi Singh
# Python3 program to find the count
# of subarrays of an Array having all
# unique digits
# Function to obtain
# the mask for any integer
def getmask(val):
mask = 0
if val == 0:
return 1
while (val):
d = val % 10;
mask |= (1 << d)
val = val // 10
return mask
# Function to count the number of ways
def countWays(pos, mask, a, n):
# Subarray must not be empty
if pos == n :
if mask > 0:
return 1
else:
return 0
# If subproblem has been solved
if dp[pos][mask] != -1:
return dp[pos][mask]
count = 0
# Excluding this element in the subarray
count = (count +
countWays(pos + 1, mask, a, n))
# If there are no common digits
# then only this element can be included
if (getmask(a[pos]) & mask) == 0:
# Calculate the new mask
# if this element is included
new_mask = (mask | (getmask(a[pos])))
count = (count +
countWays(pos + 1,
new_mask,
a, n))
# Store and return the answer
dp[pos][mask] = count
return count
# Function to find the count of
# subarray with all digits unique
def numberOfSubarrays(a, n):
return countWays(0, 0, a, n)
# Driver Code
N = 4
A = [ 1, 12, 23, 34 ]
rows = 5000
cols = 1100
# Initializing dp
dp = [ [ -1 for i in range(cols) ]
for j in range(rows) ]
print( numberOfSubarrays(A, N))
# This code is contributed by sarthak_eddy.
// C# program to find the count
// of subarrays of an Array
// having all unique digits
using System;
public class GFG{
// Dynamic programming table
static int [,]dp = new int[5000, (1 << 10) + 5];
// Function to obtain
// the mask for any integer
static int getmask(int val)
{
int mask = 0;
if (val == 0)
return 1;
while (val > 0) {
int d = val % 10;
mask |= (1 << d);
val /= 10;
}
return mask;
}
// Function to count the number of ways
static int countWays(int pos, int mask,
int []a, int n)
{
// Subarray must not be empty
if (pos == n)
return (mask > 0 ? 1 : 0);
// If subproblem has been solved
if (dp[pos, mask] != -1)
return dp[pos, mask];
int count = 0;
// Excluding this element in the subarray
count = count
+ countWays(pos + 1, mask, a, n);
// If there are no common digits
// then only this element can be included
if ((getmask(a[pos]) & mask) == 0) {
// Calculate the new mask
// if this element is included
int new_mask
= (mask | (getmask(a[pos])));
count = count
+ countWays(pos + 1,
new_mask, a, n);
}
// Store and return the answer
return dp[pos, mask] = count;
}
// Function to find the count of
// subarray with all digits unique
static int numberOfSubarrays(int []a, int n)
{
// initializing dp
for(int i = 0; i < 5000; i++)
{
for (int j = 0; j < (1 << 10) + 5; j++) {
dp[i,j] = -1;
}
}
return countWays(0, 0, a, n);
}
// Driver code
public static void Main(String[] args)
{
int N = 4;
int []A = { 1, 12, 23, 34 };
Console.Write(numberOfSubarrays(A, N));
}
}
// This code contributed by sapnasingh4991
<script>
// Javascript program to find the count
// of subarrays of an Array
// having all unique digits
// Dynamic programming table
var dp = Array.from(Array(5000), ()=>Array((1 << 10) + 5).fill(-1));
// Function to obtain
// the mask for any integer
function getmask(val)
{
var mask = 0;
if (val == 0)
return 1;
while (val) {
var d = val % 10;
mask |= (1 << d);
val = parseInt(val/10);
}
return mask;
}
// Function to count the number of ways
function countWays(pos, mask, a, n)
{
// Subarray must not be empty
if (pos == n)
return (mask > 0 ? 1 : 0);
// If subproblem has been solved
if (dp[pos][mask] != -1)
return dp[pos][mask];
var count = 0;
// Excluding this element in the subarray
count = count
+ countWays(pos + 1, mask, a, n);
// If there are no common digits
// then only this element can be included
if ((getmask(a[pos]) & mask) == 0) {
// Calculate the new mask
// if this element is included
var new_mask
= (mask | (getmask(a[pos])));
count = count
+ countWays(pos + 1,
new_mask,
a, n);
}
// Store and return the answer
return dp[pos][mask] = count;
}
// Function to find the count of
// subarray with all digits unique
function numberOfSubarrays(a, n)
{
// initializing dp
dp = Array.from(Array(5000), ()=>Array((1 << 10) + 5).fill(-1));
return countWays(0, 0, a, n);
}
// Driver code
var N = 4;
var A = [1, 12, 23, 34];
document.write( numberOfSubarrays(A, N));
</script>
Time Complexity: O(N * 210)
Similar Reads
Count of distinct GCDs among all the non-empty subsequences of given array
Given an integer array arr[] of size N, the task is to calculate the total number of distinct Greatest Common Divisors(GCDs) among all the non-empty subsequences of arr[]. Examples: Input: arr[]={3,4,8} N=3Output:4Explanation:The different non-empty subsequences possible are {3}, {4}, {8}, {3,4}, {4
8 min read
Count subsequences of Array having single digit integer sum K
Given an array arr[] and integer K, the task is to count the number of subsequences of the array such that after adding all the elements of that subsequences their single digit integer sum is exactly K. Note: Single digit integer sum is obtained by replacing a number with its digit sum until the num
8 min read
Sum of all subsequences of an array
Given an array of n integers. Find the sum of all possible subsequences of an array. Examples : Input : arr[] = { 1, 2 } Output : 6 All possible subsequences are {}, {1}, {2} and { 1, 2 } Input : arr[] = { 1, 2, 3 } Output : 24Recommended: Please solve it on “PRACTICE †first, before moving on to th
4 min read
Count of subsequences having odd Bitwise AND values in the given array
Given an array arr[] of N integers, the task is to find the number of subsequences of the given array such that their Bitwise AND value is Odd. Examples: Input: arr[] = {2, 3, 1}Output: 3Explanation: The subsequences of the given array having odd Bitwise AND values are {3} = 3, {1} = 1, {3, 1} = 3
5 min read
Count subsequences having odd Bitwise OR values in an array
Given an array arr[] consisting of N positive integers, the task is to find the number of subsequences from the given array whose Bitwise OR value is odd. Examples: Input: arr = [2, 4, 1]Output: 4Explanation: Subsequences with odd Bitwise OR values are {1}, {2, 1}, {4, 1}, {2, 4, 1} Input: arr = [1,
5 min read
Count of subsequences of Array with last digit of product as K
Given an array A[] of size N and a digit K. Find the number of sub-sequences of the array where the last digit of the product of the elements of the sub-sequence is K. Example: Input: A = {2, 3, 4, 2}, K = 2Output: 4Explanation: sub-sequences with product's last digit = 2 are: {2}, {2}, {2, 3, 2}, {
12 min read
Count subsequences having odd Bitwise XOR values from an array
Given an array A[] of size N, the task is to count the number of subsequences from the given array whose Bitwise XOR value is odd. Examples: Input: A[] = {1, 3, 4}Output: 4Explanation: Subsequences with odd Bitwise XOR are {1}, {3}, {1, 4}, {3, 4}. Input: A[] = {2, 8, 6}Output: 0Explanation: No such
5 min read
Count of possible subarrays and subsequences using given length of Array
Given an integer N which denotes the length of an array, the task is to count the number of subarray and subsequence possible with the given length of the array.Examples: Input: N = 5 Output: Count of subarray = 15 Count of subsequence = 32Input: N = 3 Output: Count of subarray = 6 Count of subseque
3 min read
Count of all subsequences having adjacent elements with different parity
Given an array arr[] of size N, the task is to find the number of non-empty subsequences from the given array such that no two adjacent elements of the subsequence have the same parity. Examples: Input: arr[] = [5, 6, 9, 7] Output: 9 Explanation: All such subsequences of given array will be {5}, {6}
9 min read
Count of substrings having all distinct characters
Given a string str consisting of lowercase alphabets, the task is to find the number of possible substrings (not necessarily distinct) that consists of distinct characters only.Examples: Input: Str = "gffg" Output: 6 Explanation: All possible substrings from the given string are, ( "g", "gf", "gff",
7 min read