# Count of subsequences of Array with last digit of product as K

• Last Updated : 07 Apr, 2022

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 = 2
Output: 4
Explanation:  sub-sequences with product’s last digit = 2 are: {2}, {2}, {2, 3, 2}, {3, 4}

Input: A = {1, 1, 1, 2}, K = 1
Output: 7
Explanation: The sub-sequences with product’s last digit = 2 are: {1}, {1}, {1}, {1, 1}, {1, 1}, {1, 1},  {1, 1, 1}

Approach: The above problem can be solved using recursion based on below idea:

We will use the recursive approach to find each possible sub-sequences, and on the go we will calculate the product of the elements and keep track of the last digit p, then at end we check if p is equal to K we return 1 else return 0.

Illustration:

Note: during multiplication of two numbers say a = 133 and b = 26
133
x 26
——
1798   <— last digit gets multiplied only once
266X
——
3458   (3*6 = 18,  both have 8 as last digits)
So the last digit of the a*b will be equal to the last digit of product of last digits of a and b
Suppose we have numbers 11, 233, 783, 4759, 6
product of the numbers = 57302995266
product of just the last digits, i.e., 1, 3, 3, 9, 6 = 486
Both have last digit as 6

Follow the below steps to solve the problem:

• Base Case: if p is equal to K return 1, else return 0
• There are two options either take the element or don’t.
• if we take the element, then the product p gets updated to p*a[n-1], as we are just bothered about the last digit so we can just update p to the last digit of p*a[n-1], i.e., p becomes p*a[n-1]%10.
• other option is don’t take the element, so don’t update p and do n-1, to look for other possibilities.
• As we need the total number of such sub-sequences we return the sum of the above two calls.
• An edge case is if K=1, then we will get one extra sub-sequence that is an empty sub-sequence, as we initially take p=1 so in an empty sub-sequence we get p==k and 1 is returned. So when K==1 we deduct 1 from the answer.

Time Complexity:  O(2N)
Auxiliary Space:  O(N)

Efficient Approach: Since Recursion takes exponential time complexity, the above recursive approach can be optimized further using Dynamic Programming. We will construct a look-up table and memoize the recursive code in order to do so.

Below is the implementation of the above approach:

## C++

 `// C++ program for Count the number of``// sub-sequences of an  array where the last digit``// of the product of the subsequence is K.``#include ``using` `namespace` `std;` `int` `dp[1001][10];``// recursive utility function``int` `countSubsequencesUtil(``int` `n, ``int` `k, ``int` `p,``                          ``vector<``int``>& a)``{``    ``// Base case``    ``if` `(n == 0) {``        ``if` `(p == k)``            ``return` `1;``        ``else``            ``return` `0;``    ``}` `    ``// return pre calculated value from``    ``// look-up table``    ``if` `(dp[n][p] != -1)``        ``return` `dp[n][p];` `    ``// return the total number obtained through``    ``// option1 and option2``    ``return` `dp[n][p]``           ``= countSubsequencesUtil(n - 1, k,``                                   ``(p * a[n - 1]) % 10, a)``             ``+ countSubsequencesUtil(n - 1, k, p, a);``}``// Function to  Count the number of subsequences``int` `countSubsequences(vector<``int``>& a, ``int` `k)``{``    ``// initialize the table with -1``    ``memset``(dp, -1, ``sizeof``(dp));` `    ``int` `n = a.size();``    ``int` `ans = countSubsequencesUtil(n, k, 1, a);` `    ``// if k is 1 return 1 less``    ``if` `(k == 1)``        ``return` `ans - 1;` `    ``return` `ans;``}` `// Driver Code``int` `main()``{``    ``vector<``int``> a = { 2, 3, 4, 2 };``    ``int` `k = 2;` `    ``cout << countSubsequences(a, k);` `    ``return` `0;``}`

## Java

 `// Java program to count the number of subsequences``// of an array where the last digit of the product``// of the subsequence is K``import` `java.io.*;``import` `java.util.*;` `public` `class` `GFG {` `  ``static` `int``[][] dp = ``new` `int``[``1001``][``10``];` `  ``// recursive utility function``  ``static` `int` `countSubsequencesUtil(``int` `n, ``int` `k, ``int` `p,``                                   ``int``[] a)``  ``{``    ``// base case``    ``if` `(n == ``0``) {``      ``if` `(p == k)``        ``return` `1``;``      ``return` `0``;``    ``}` `    ``// return pre calculated value from``    ``// look up table``    ``if` `(dp[n][p] != -``1``)``      ``return` `dp[n][p];` `    ``// return the total no. obtained through``    ``// option1 and option2``    ``return` `dp[n][p]``      ``= countSubsequencesUtil(n - ``1``, k,``                              ``(p * a[n - ``1``]) % ``10``, a)``      ``+ countSubsequencesUtil(n - ``1``, k, p, a);``  ``}` `  ``// function to count the number of subsequences``  ``static` `int` `countSubsequences(``int``[] a, ``int` `k)``  ``{` `    ``// initializing all elements of table with -1``    ``for` `(``int` `i = ``0``; i <= ``1000``; i++) {``      ``for` `(``int` `j = ``0``; j < ``10``; j++) {``        ``dp[i][j] = -``1``;``      ``}``    ``}` `    ``int` `n = a.length;``    ``int` `ans = countSubsequencesUtil(n, k, ``1``, a);` `    ``// if k is 1 return 1 less``    ``if` `(k == ``1``)``      ``return` `ans - ``1``;` `    ``return` `ans;``  ``}` `  ``// Driver Code``  ``public` `static` `void` `main(String[] args)``  ``{``    ``int``[] a = { ``2``, ``3``, ``4``, ``2` `};``    ``int` `k = ``2``;``    ``System.out.print(countSubsequences(a, k));``  ``}``}` `// This code is contributed by phasing17`

## Python3

 `# Python implementation of above approach``dp ``=` `[[``-``1``]``*``10``]``*``1001` `# recursive utility function``def` `countSubsequencesUtil(n, k, p, a) :``    ` `    ``# Base case``    ``if` `(n ``=``=` `0``) :``        ``if` `(p ``=``=` `k):``            ``return` `1``        ``else``:``            ``return` `0``    ` `    ``# return pre calculated value from``    ``# look-up table``    ``if` `(dp[n][p] !``=` `-``1``):``        ``return` `dp[n][p]` `    ``# return the total number obtained through``    ``# option1 and option2``    ``dp[n][p] ``=` `(countSubsequencesUtil(n ``-` `1``, k,(p ``*` `a[n ``-` `1``]) ``%` `10``, a) ``+``                    ``countSubsequencesUtil(n ``-` `1``, k, p, a));``    ``return` `(dp[n][p]);` `# Function to  Count the number of subsequences``def` `countSubsequences(a, k) :` `    ``n ``=` `len``(a)``    ``ans ``=` `countSubsequencesUtil(n, k, ``1``, a)` `    ``# if k is 1 return 1 less``    ``if` `(k ``=``=` `1``) :``        ``return` `(ans ``-` `1``)` `    ``return` `ans ``+` `1` `# Driver Code``a ``=` `[ ``2``, ``3``, ``4``, ``2` `]``k ``=` `2` `print``(countSubsequences(a, k))` `# This code is contributed by sanjoy_62.`

## C#

 `// C# program for Count the number of``// sub-sequences of an  array where the last digit``// of the product of the subsequence is K.``using` `System;``class` `GFG {` `    ``static` `int``[, ] dp = ``new` `int``[1001, 10];``    ``// recursive utility function``    ``static` `int` `countSubsequencesUtil(``int` `n, ``int` `k, ``int` `p,``                                     ``int``[] a)``    ``{``        ``// Base case``        ``if` `(n == 0) {``            ``if` `(p == k)``                ``return` `1;``            ``else``                ``return` `0;``        ``}` `        ``// return pre calculated value from``        ``// look-up table``        ``if` `(dp[n, p] != -1)``            ``return` `dp[n, p];` `        ``// return the total number obtained through``        ``// option1 and option2``        ``return` `dp[n, p]``            ``= countSubsequencesUtil(n - 1, k,``                                    ``(p * a[n - 1]) % 10, a)``              ``+ countSubsequencesUtil(n - 1, k, p, a);``    ``}``    ``// Function to  Count the number of subsequences``    ``static` `int` `countSubsequences(``int``[] a, ``int` `k)``    ``{``        ``// initialize the table with -1``        ``for` `(``int` `i = 0; i < 1001; i++) {``            ``for` `(``int` `j = 0; j < 10; j++) {``                ``dp[i, j] = -1;``            ``}``        ``}` `        ``int` `n = a.Length;``        ``int` `ans = countSubsequencesUtil(n, k, 1, a);` `        ``// if k is 1 return 1 less``        ``if` `(k == 1)``            ``return` `ans - 1;` `        ``return` `ans;``    ``}` `    ``// Driver Code``    ``public` `static` `void` `Main()``    ``{``        ``int``[] a = { 2, 3, 4, 2 };``        ``int` `k = 2;` `        ``Console.Write(countSubsequences(a, k));``    ``}``}` `// This code is contributed by Samim Hossain Mondal.`

## Javascript

 ``

Output

`4`

Time Complexity:  O(N)
Auxiliary Space:  O(N)

My Personal Notes arrow_drop_up