Count of N-digit Numbers having Sum of even and odd positioned digits divisible by given numbers
Last Updated :
11 May, 2021
Given integers A, B, and N, the task is to find the total number of N-digit numbers whose sum of digits at even positions and odd positions are divisible by A and B respectively.
Examples:
Input: N = 2, A = 2, B = 5
Output: 5
Explanation:
The only 2-digit numbers {50, 52, 54, 56, 58} with sum of odd-positioned digits equal to 5 and even-positioned digits {0, 2, 4, 6, 8} divisible by 2.
Input: N = 2, A = 5, B = 3
Output: 6
Explanation:
The only two-digit numbers {30, 35, 60, 65, 90, 95} have odd digits {3, 6 or 9}, which is divisible by 3 and even digits {0 or 5}, which is divisible by 5.
Naive Approach: The simplest approach to solve this problem is to iterate over all possible N-digit numbers and for each number, check if the sum of digits at even positions is divisible by A and the sum of digits at odd positions is divisible by B or not. If found to be true, increase count.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
long reverse(long num)
{
long rev = 0;
while (num > 0)
{
int r = (int)(num % 10);
rev = rev * 10 + r;
num /= 10;
}
return rev;
}
long count(int N, int A, int B)
{
long l = (long)pow(10, N - 1),
r = (long)pow(10, N) - 1;
if (l == 1)
l = 0;
long ans = 0;
for(long i = l; i <= r; i++)
{
int even_sum = 0, odd_sum = 0;
long itr = 0, num = reverse(i);
while (num > 0)
{
if (itr % 2 == 0)
odd_sum += num % 10;
else
even_sum += num % 10;
num /= 10;
itr++;
}
if (even_sum % A == 0 &&
odd_sum % B == 0)
ans++;
}
return ans;
}
int main()
{
int N = 2, A = 5, B = 3;
cout << (count(N, A, B));
}
|
Java
class GFG {
public static long reverse(long num)
{
long rev = 0;
while (num > 0) {
int r = (int)(num % 10);
rev = rev * 10 + r;
num /= 10;
}
return rev;
}
public static long count(int N, int A, int B)
{
long l = (long)Math.pow(10, N - 1),
r = (long)Math.pow(10, N) - 1;
if (l == 1)
l = 0;
long ans = 0;
for (long i = l; i <= r; i++) {
int even_sum = 0, odd_sum = 0;
long itr = 0, num = reverse(i);
while (num > 0) {
if (itr % 2 == 0)
odd_sum += num % 10;
else
even_sum += num % 10;
num /= 10;
itr++;
}
if (even_sum % A == 0
&& odd_sum % B == 0)
ans++;
}
return ans;
}
public static void main(String[] args)
{
int N = 2, A = 5, B = 3;
System.out.println(count(N, A, B));
}
}
|
Python3
def reverse(num):
rev = 0;
while (num > 0):
r = int(num % 10);
rev = rev * 10 + r;
num = num // 10;
return rev;
def count(N, A, B):
l = int(pow(10, N - 1));
r = int(pow(10, N) - 1);
if (l == 1):
l = 0;
ans = 0;
for i in range(l, r + 1):
even_sum = 0;
odd_sum = 0;
itr = 0;
num = reverse(i);
while (num > 0):
if (itr % 2 == 0):
odd_sum += num % 10;
else:
even_sum += num % 10;
num = num // 10;
itr += 1;
if (even_sum % A == 0 and
odd_sum % B == 0):
ans += 1;
return ans;
if __name__ == '__main__':
N = 2;
A = 5;
B = 3;
print(count(N, A, B));
|
C#
using System;
class GFG{
public static long reverse(long num)
{
long rev = 0;
while (num > 0)
{
int r = (int)(num % 10);
rev = rev * 10 + r;
num /= 10;
}
return rev;
}
public static long count(int N, int A, int B)
{
long l = (long)Math.Pow(10, N - 1),
r = (long)Math.Pow(10, N) - 1;
if (l == 1)
l = 0;
long ans = 0;
for(long i = l; i <= r; i++)
{
int even_sum = 0, odd_sum = 0;
long itr = 0, num = reverse(i);
while (num > 0)
{
if (itr % 2 == 0)
odd_sum += (int)num % 10;
else
even_sum += (int)num % 10;
num /= 10;
itr++;
}
if (even_sum % A == 0 &&
odd_sum % B == 0)
ans++;
}
return ans;
}
public static void Main(String[] args)
{
int N = 2, A = 5, B = 3;
Console.WriteLine(count(N, A, B));
}
}
|
Javascript
<script>
function reverse(num) {
var rev = 0;
while (num > 0) {
var r = parseInt( (num % 10));
rev = rev * 10 + r;
num = parseInt(num/10);
}
return rev;
}
function count(N , A , B) {
var l = Math.pow(10, N - 1), r = Math.pow(10, N) - 1;
if (l == 1)
l = 0;
var ans = 0;
for (i = l; i <= r; i++) {
var even_sum = 0, odd_sum = 0;
var itr = 0, num = reverse(i);
while (num > 0) {
if (itr % 2 == 0)
odd_sum += num % 10;
else
even_sum += num % 10;
num = parseInt(num/10);
itr++;
}
if (even_sum % A == 0 && odd_sum % B == 0)
ans++;
}
return ans;
}
var N = 2, A = 5, B = 3;
document.write(count(N, A, B));
</script>
|
Time Complexity: O((10N – 10N – 1 – 1) * N)
Auxiliary Space: O(N)
Efficient Approach: To optimize the above approach, use the concept of Dynamic Programming.
Follow the steps below to solve the problem:
- Since the even-positioned digits and the odd-positioned digits are not dependent on each other, therefore, the given problem can be broken down into two subproblems:
- For even-positioned digits: Total count of sequences of N/2 digits from 0 to 9 (repetitions allowed) such that the sum of digits is divisible by A, where the first digit can be zero.
- For odd-positioned digits: Total count of sequences of Ceil(N/2) digits from 0 to 9 (repetitions allowed) such that the sum of digits is divisible by B, where the first digit cannot be zero.
- The required result is the product of the above two.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
long count(int N, int A, int B)
{
if (N == 1)
{
return 9 / B + 1;
}
int max_sum = 9 * N;
int odd_count = N / 2 + N % 2;
int even_count = N - odd_count;
long dp[even_count][max_sum + 1] = {0};
for (int i = 0; i <= 9; i++)
dp[0][i % A]++;
for (int i = 1; i < even_count; i++)
{
for (int j = 0; j <= 9; j++)
{
for (int k = 0; k <= max_sum; k++)
{
if (dp[i - 1][k] > 0)
dp[i][(j + k) % A] += dp[i - 1][k];
}
}
}
long dp1[odd_count][max_sum + 1] = {0};
for (int i = 1; i <= 9; i++)
dp1[0][i % B]++;
for (int i = 1; i < odd_count; i++)
{
for (int j = 0; j <= 9; j++)
{
for (int k = 0; k <= max_sum; k++)
{
if (dp1[i - 1][k] > 0)
dp1[i][(j + k) % B] += dp1[i - 1][k];
}
}
}
return dp[even_count - 1][0] * dp1[odd_count - 1][0];
}
int main()
{
int N = 2, A = 2, B = 5;
cout << count(N, A, B);
}
|
Java
class GFG {
public static long count(int N, int A, int B)
{
if (N == 1) {
return 9 / B + 1;
}
int max_sum = 9 * N;
int odd_count = N / 2 + N % 2;
int even_count = N - odd_count;
long dp[][]
= new long[even_count][max_sum + 1];
for (int i = 0; i <= 9; i++)
dp[0][i % A]++;
for (int i = 1; i < even_count; i++) {
for (int j = 0; j <= 9; j++) {
for (int k = 0; k <= max_sum; k++) {
if (dp[i - 1][k] > 0)
dp[i][(j + k) % A]
+= dp[i - 1][k];
}
}
}
long dp1[][]
= new long[odd_count][max_sum + 1];
for (int i = 1; i <= 9; i++)
dp1[0][i % B]++;
for (int i = 1; i < odd_count; i++) {
for (int j = 0; j <= 9; j++) {
for (int k = 0; k <= max_sum; k++) {
if (dp1[i - 1][k] > 0)
dp1[i][(j + k) % B]
+= dp1[i - 1][k];
}
}
}
return dp[even_count - 1][0]
* dp1[odd_count - 1][0];
}
public static void main(String[] args)
{
int N = 2, A = 2, B = 5;
System.out.println(count(N, A, B));
}
}
|
Python3
def count(N, A, B):
if (N == 1):
return 9 // B + 1
max_sum = 9 * N
odd_count = N // 2 + N % 2
even_count = N - odd_count
dp = [[0 for x in range (max_sum + 1)]
for y in range (even_count)]
for i in range(10):
dp[0][i % A] += 1
for i in range (1, even_count):
for j in range (10):
for k in range (max_sum + 1):
if (dp[i - 1][k] > 0):
dp[i][(j + k) % A] += dp[i - 1][k]
dp1 = [[0 for x in range (max_sum)]
for y in range (odd_count)]
for i in range (1, 10):
dp1[0][i % B] += 1
for i in range (1, odd_count):
for j in range (10):
for k in range (max_sum + 1):
if (dp1[i - 1][k] > 0):
dp1[i][(j + k) % B] += dp1[i - 1][k]
return dp[even_count - 1][0] * dp1[odd_count - 1][0]
if __name__ == "__main__":
N = 2
A = 2
B = 5
print (count(N, A, B))
|
C#
using System;
class GFG{
public static long count(int N, int A, int B)
{
if (N == 1)
{
return 9 / B + 1;
}
int max_sum = 9 * N;
int odd_count = N / 2 + N % 2;
int even_count = N - odd_count;
long [,]dp = new long[even_count, max_sum + 1];
for(int i = 0; i <= 9; i++)
dp[0, i % A]++;
for(int i = 1; i < even_count; i++)
{
for(int j = 0; j <= 9; j++)
{
for(int k = 0; k <= max_sum; k++)
{
if (dp[i - 1, k] > 0)
dp[i, (j + k) % A] += dp[i - 1, k];
}
}
}
long [,]dp1 = new long[odd_count, max_sum + 1];
for(int i = 1; i <= 9; i++)
dp1[0, i % B]++;
for(int i = 1; i < odd_count; i++)
{
for(int j = 0; j <= 9; j++)
{
for(int k = 0; k <= max_sum; k++)
{
if (dp1[i - 1, k] > 0)
dp1[i, (j + k) % B] += dp1[i - 1, k];
}
}
}
return dp[even_count - 1, 0] *
dp1[odd_count - 1, 0];
}
public static void Main(String[] args)
{
int N = 2, A = 2, B = 5;
Console.WriteLine(count(N, A, B));
}
}
|
Javascript
<script>
function count(N, A, B)
{
if (N == 1) {
return 9 / B + 1;
}
let max_sum = 9 * N;
let odd_count = N / 2 + N % 2;
let even_count = N - odd_count;
let dp
= new Array(even_count);
for (var i = 0; i < dp.length; i++) {
dp[i] = new Array(2);
}
for (var i = 0; i < even_count; i++) {
for (var j = 0; j < max_sum + 1; j++) {
dp[i][j] = 0;
}
}
for (let i = 0; i <= 9; i++)
dp[0][i % A]++;
for (let i = 1; i < even_count; i++) {
for (let j = 0; j <= 9; j++) {
for (let k = 0; k <= max_sum; k++) {
if (dp[i - 1][k] > 0)
dp[i][(j + k) % A]
+= dp[i - 1][k];
}
}
}
let dp1
= new Array(odd_count);
for (var i = 0; i < dp1.length; i++) {
dp1[i] = new Array(2);
}
for (var i = 0; i < odd_count; i++) {
for (var j = 0; j < max_sum + 1; j++) {
dp1[i][j] = 0;
}
}
for (let i = 1; i <= 9; i++)
dp1[0][i % B]++;
for (let i = 1; i < odd_count; i++) {
for (let j = 0; j <= 9; j++) {
for (let k = 0; k <= max_sum; k++) {
if (dp1[i - 1][k] > 0)
dp1[i][(j + k) % B]
+= dp1[i - 1][k];
}
}
}
return dp[even_count - 1][0]
* dp1[odd_count - 1][0];
}
let N = 2, A = 2, B = 5;
document.write(count(N, A, B));
</script>
|
Time Complexity: O(N2)
Auxiliary Space: O(N2)
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...