Open in App
Not now

# Count ways to generate N digit number such that its every digit divisible by previous digit

• Difficulty Level : Hard
• Last Updated : 31 Mar, 2023

Given a number N, the task is to count the number of ways to create an N digit number from digits 1 to 9 such that every digit is divisible by its previous digit that is if the number is represented by an array of digits A then A[i + 1] % A[i] == 0. print the answer modulo 109 + 7.

Examples:

Input: N = 2
Output: 23
Explanation: For N = 2 possible answers are 11, 12, 13, 14, 15, 16, 17, 18, 19, 22, 24, 26, 28, 33, 36, 39, 44, 48, 55, 66, 77, 88, and 99.

Input: N = 3
Output:  44

Naive approach: The basic way to solve the problem is as follows:

The basic way to solve this problem is to generate all possible combinations by using a recursive approach.

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

Efficient Approach:  The above approach can be optimized based on the following idea:

Dynamic programming can be used to solve this problem

• dp[i][j] represents the number of ways of creating a number of size i and j is its previous digit taken.
• It can be observed that the recursive function is called exponential times. That means that some states are called repeatedly.
• So the idea is to store the value of each state. This can be done by storing the value of a state and whenever the function is called, returning the stored value without computing again.

Follow the steps below to solve the problem:

• Create a recursive function that takes two parameters representing ith position to be filled and j representing the last digit taken.
• Call the recursive function for choosing all digits from 1 to 9.
• Base case if all positions filled return 1.
• Create a 2d array of dp[N][10] initially filled with -1.
• If the answer for a particular state is computed then save it in dp[i][j].
• If the answer for a particular state is already computed then just return dp[i][j].

Below is the implementation of the above approach:

## C++

 `// C++ code to implement the approach` `#include ` `using` `namespace` `std;`   `const` `int` `MOD = 1e9 + 7;`   `// DP table initialized with -1` `int` `dp[100001][10];`   `// Recursive Function to find number of N` `// digits such that its every digit` `// divisible by its previous digit` `int` `recur(``int` `i, ``int` `j, ``int` `N)` `{`   `    ``// Base case` `    ``if` `(i == N) {` `        ``return` `1;` `    ``}`   `    ``// If answer for current state is` `    ``// already calculated then just` `    ``// return dp[i][j]` `    ``if` `(dp[i][j] != -1)` `        ``return` `dp[i][j];`   `    ``// Answer initialized with zero` `    ``int` `ans = 0;`   `    ``// First element to decide` `    ``if` `(i == 0) {`   `        ``// Iterating for all digits from` `        ``// 1 to 9` `        ``for` `(``int` `digit = 1; digit <= 9; digit++) {`   `            ``// Choosing this as` `            ``// current digit` `            ``ans = (ans + recur(i + 1, digit, N)) % MOD;` `        ``}` `    ``}`   `    ``// Choosing for other positions apart` `    ``// from first` `    ``else` `{`   `        ``// Iterating for all digits` `        ``// from 1 to 9` `        ``for` `(``int` `digit = 1; digit <= 9; digit++) {`   `            ``// Choosing this as current` `            ``// digit if it is divisible by` `            ``// previous digit` `            ``if` `(digit % j == 0)` `                ``ans = (ans + recur(i + 1, digit, N)) % MOD;` `        ``}` `    ``}`   `    ``// Save and return dp value` `    ``return` `dp[i][j] = ans;` `}`   `// Function to find number of N digits` `// such that its every digit divisible` `// by its previous digit` `int` `countWays(``int` `N)` `{`   `    ``// Initializing dp array with - 1` `    ``memset``(dp, -1, ``sizeof``(dp));`   `    ``// Calling recursive function for` `    ``// finding answer` `    ``int` `ans = recur(0, 0, N);`   `    ``// Returning the answer` `    ``return` `ans;` `}`   `// Driver Code` `int` `main()` `{`   `    ``// Input 1` `    ``int` `N = 2;`   `    ``// Function Call` `    ``cout << countWays(N) << endl;`   `    ``// Input 2` `    ``int` `N1 = 3;`   `    ``// Function Call` `    ``cout << countWays(N1) << endl;` `    ``return` `0;` `}`

## Java

 `// Java code to implement the approach`   `import` `java.io.*;` `import` `java.util.*;`   `class` `GFG {`   `  ``static` `final` `int` `MOD = (``int``)1e9 + ``7``;` `  ``static` `int``[][] dp;`   `  ``// Recursive Function to find number of N` `  ``// digits such that its every digit` `  ``// divisible by its previous digit` `  ``static` `int` `recur(``int` `i, ``int` `j, ``int` `N)` `  ``{` `    ``// Base case` `    ``if` `(i == N) {` `      ``return` `1``;` `    ``}` `    ``// If answer for current state is` `    ``// already calculated then just` `    ``// return dp[i][j]` `    ``if` `(dp[i][j] != -``1``) {` `      ``return` `dp[i][j];` `    ``}`   `    ``// Answer initialized with zero` `    ``int` `ans = ``0``;`   `    ``// First element to decide` `    ``if` `(i == ``0``) {` `      ``// Iterating for all digits from` `      ``// 1 to 9` `      ``for` `(``int` `digit = ``1``; digit <= ``9``; digit++) {` `        ``// Choosing this as` `        ``// current digit` `        ``ans = (ans + recur(i + ``1``, digit, N)) % MOD;` `      ``}` `    ``}` `    ``else` `{` `      ``// Choosing for other positions apart` `      ``// from first` `      ``// Iterating for all digits` `      ``// from 1 to 9` `      ``for` `(``int` `digit = ``1``; digit <= ``9``; digit++) {` `        ``// Choosing this as current` `        ``// digit if it is divisible by` `        ``// previous digit` `        ``if` `(digit % j == ``0``) {` `          ``ans = (ans + recur(i + ``1``, digit, N))` `            ``% MOD;` `        ``}` `      ``}` `    ``}`   `    ``// Save and return dp value` `    ``return` `dp[i][j] = ans;` `  ``}`   `  ``// Function to find number of N digits` `  ``// such that its every digit divisible` `  ``// by its previous digit` `  ``static` `int` `countWays(``int` `N)` `  ``{` `    ``// Initializing dp array with - 1` `    ``dp = ``new` `int``[N + ``1``][``10``];` `    ``for` `(``int``[] row : dp) {` `      ``Arrays.fill(row, -``1``);` `    ``}` `    ``// Calling recursive function for` `    ``// finding answer` `    ``int` `ans = recur(``0``, ``0``, N);` `    ``// Returning the answer` `    ``return` `ans;` `  ``}`   `  ``public` `static` `void` `main(String[] args)` `  ``{` `    ``// Input 1` `    ``int` `N = ``2``;` `    ``// Function Call` `    ``System.out.println(countWays(N));` `    ``// Input 2` `    ``int` `N1 = ``3``;` `    ``// Function Call` `    ``System.out.println(countWays(N1));` `  ``}` `}`   `// This code is contributed by lokesh.`

## Python3

 `MOD ``=` `1e9` `+` `7`   `# DP table initialized with -1` `dp ``=` `[[``-``1` `for` `j ``in` `range``(``10``)] ``for` `i ``in` `range``(``100001``)]`   `# Recursive Function to find number of N` `# digits such that its every digit` `# divisible by its previous digit` `def` `recur(i, j, N):`   `    ``# Base case` `    ``if` `i ``=``=` `N:` `        ``return` `1`   `    ``# If answer for current state is` `    ``# already calculated then just` `    ``# return dp[i][j]` `    ``if` `dp[i][j] !``=` `-``1``:` `        ``return` `dp[i][j]`   `    ``# Answer initialized with zero` `    ``ans ``=` `0`   `    ``# First element to decide` `    ``if` `i ``=``=` `0``:`   `        ``# Iterating for all digits from` `        ``# 1 to 9` `        ``for` `digit ``in` `range``(``1``, ``10``):`   `            ``# Choosing this as` `            ``# current digit` `            ``ans ``=` `(ans ``+` `recur(i ``+` `1``, digit, N)) ``%` `MOD` `    ``# Choosing for other positions apart` `    ``# from first` `    ``else``:`   `        ``# Iterating for all digits` `        ``# from 1 to 9` `        ``for` `digit ``in` `range``(``1``, ``10``):`   `            ``# Choosing this as current` `            ``# digit if it is divisible by` `            ``# previous digit` `            ``if` `digit ``%` `j ``=``=` `0``:` `                ``ans ``=` `(ans ``+` `recur(i ``+` `1``, digit, N)) ``%` `MOD`   `    ``# Save and return dp value` `    ``dp[i][j] ``=` `ans` `    ``return` `ans`   `# Function to find number of N digits` `# such that its every digit divisible` `# by its previous digit` `def` `count_ways(N):`   `    ``# Calling recursive function for` `    ``# finding answer` `    ``ans ``=` `recur(``0``, ``0``, N)`   `    ``# Returning the answer` `    ``return` `ans`   `# Driver Code`   `# Input 1` `N ``=` `2`   `# Function Call` `print``(count_ways(N))`   `# Input 2` `N1 ``=` `3` `dp ``=` `[[``-``1` `for` `j ``in` `range``(``10``)] ``for` `i ``in` `range``(``100001``)]`   `# Function Call` `print``(count_ways(N1))`   `# This code is contributed by lokeshpotta20.`

## C#

 `// C# code to implement the approach`   `using` `System;`   `public` `class` `GFG {`   `  ``static` `readonly` `int` `MOD = (``int``)1e9 + 7;` `  ``static` `int``[, ] dp;`   `  ``// Recursive Function to find number of N` `  ``// digits such that its every digit` `  ``// divisible by its previous digit` `  ``static` `int` `recur(``int` `i, ``int` `j, ``int` `N)` `  ``{` `    ``// Base case` `    ``if` `(i == N) {` `      ``return` `1;` `    ``}` `    ``// If answer for current state is` `    ``// already calculated then just` `    ``// return dp[i][j]` `    ``if` `(dp[i, j] != -1) {` `      ``return` `dp[i, j];` `    ``}` `    ``// Answer initialized with zero` `    ``int` `ans = 0;`   `    ``// First element to decide` `    ``if` `(i == 0) {` `      ``// Iterating for all digits from` `      ``// 1 to 9` `      ``for` `(``int` `digit = 1; digit <= 9; digit++) {` `        ``// Choosing this as` `        ``// current digit` `        ``ans = (ans + recur(i + 1, digit, N)) % MOD;` `      ``}` `    ``}` `    ``else` `{` `      ``// Choosing for other positions apart` `      ``// from first` `      ``// Iterating for all digits` `      ``// from 1 to 9` `      ``for` `(``int` `digit = 1; digit <= 9; digit++) {` `        ``// Choosing this as current` `        ``// digit if it is divisible by` `        ``// previous digit` `        ``if` `(digit % j == 0) {` `          ``ans = (ans + recur(i + 1, digit, N))` `            ``% MOD;` `        ``}` `      ``}` `    ``}`   `    ``// Save and return dp value` `    ``return` `dp[i, j] = ans;` `  ``}`   `  ``// Function to find number of N digits` `  ``// such that its every digit divisible` `  ``// by its previous digit` `  ``static` `int` `countWays(``int` `N)` `  ``{` `    ``// Initializing dp array with - 1` `    ``dp = ``new` `int``[N + 1, 10];` `    ``for` `(``int` `i = 0; i <= N; i++) {` `      ``for` `(``int` `j = 0; j <= 9; j++) {` `        ``dp[i, j] = -1;` `      ``}` `    ``}` `    ``// Calling recursive function for` `    ``// finding answer` `    ``int` `ans = recur(0, 0, N);` `    ``// Returning the answer` `    ``return` `ans;` `  ``}`   `  ``static` `public` `void` `Main()` `  ``{`   `    ``// Input 1` `    ``int` `N = 2;` `    ``// Function Call` `    ``Console.WriteLine(countWays(N));` `    ``// Input 2` `    ``int` `N1 = 3;` `    ``// Function Call` `    ``Console.WriteLine(countWays(N1));` `  ``}` `}`   `// This code is contributed by lokeshmvs21.`

## Javascript

 `// Javascript code to implement the approach` `const MOD = 1e9 + 7;`   `// DP table initialized with -1` `let dp=``new` `Array(1000001);` `for``(let i = 0; i < 1000001; i++)` `    ``dp[i] = ``new` `Array(10).fill(-1);`   `// Recursive Function to find number of N` `// digits such that its every digit` `// divisible by its previous digit` `function` `recur( i,  j,  N)` `{`   `    ``// Base case` `    ``if` `(i == N) {` `        ``return` `1;` `    ``}`   `    ``// If answer for current state is` `    ``// already calculated then just` `    ``// return dp[i][j]` `    ``if` `(dp[i][j] != -1)` `        ``return` `dp[i][j];`   `    ``// Answer initialized with zero` `    ``let ans = 0;`   `    ``// First element to decide` `    ``if` `(i == 0) {`   `        ``// Iterating for all digits from` `        ``// 1 to 9` `        ``for` `(let digit = 1; digit <= 9; digit++) {`   `            ``// Choosing this as` `            ``// current digit` `            ``ans = (ans + recur(i + 1, digit, N)) % MOD;` `        ``}` `    ``}`   `    ``// Choosing for other positions apart` `    ``// from first` `    ``else` `{`   `        ``// Iterating for all digits` `        ``// from 1 to 9` `        ``for` `(let digit = 1; digit <= 9; digit++) {`   `            ``// Choosing this as current` `            ``// digit if it is divisible by` `            ``// previous digit` `            ``if` `(digit % j == 0)` `                ``ans = (ans + recur(i + 1, digit, N)) % MOD;` `        ``}` `    ``}`   `    ``// Save and return dp value` `    ``return` `dp[i][j] = ans;` `}`   `// Function to find number of N digits` `// such that its every digit divisible` `// by its previous digit` `function` `countWays( N)` `{`   `    ``// Initializing dp array with - 1` `    ``for``(let i = 0; i < 100001; i++)` `    ``{` `        ``for``(let j = 0; j < 10; j++)` `            ``dp[i][j]=-1;` `    ``}` `    `  `    ``// Calling recursive function for` `    ``// finding answer` `    ``let ans = recur(0, 0, N);`   `    ``// Returning the answer` `    ``return` `ans;` `}`   `// Driver Code` `// Input 1` `let N = 2;`   `// Function Call` `console.log(countWays(N));`   `// Input 2` `let N1 = 3;`   `// Function Call` `console.log(countWays(N1));`   `// This code is contributed by poojaagarwal2.`

Output

```23
44```

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

Efficient approach : Using DP Tabulation method ( Iterative approach )

The approach to solve this problem is same but DP tabulation(bottom-up) method is better then Dp + memorization(top-down) because memorization method needs extra stack space of recursion calls.

Steps to solve this problem :

• Create a table to store the solution of the subproblems.
• Initialize the table with base cases
• Fill up the table iteratively
• Return the final solution

Implementation :

## C++

 `// C++ program for the above approach`   `#include ` `using` `namespace` `std;`   `const` `int` `MOD = 1e9 + 7;`   `// Function to find number of N digits` `// such that its every digit divisible` `// by its previous digit` `int` `countWays(``int` `N)` `{` `    ``// DP table to store the number of` `    ``// ways for each subproblem` `    ``vector> dp(N+1, vector<``int``>(10, 0));`   `    ``// Base case` `    ``for` `(``int` `j = 1; j <= 9; j++) {` `        ``dp[1][j] = 1;` `    ``}`   `    ``// Fill the DP table` `    ``for` `(``int` `i = 2; i <= N; i++) {` `        ``for` `(``int` `j = 1; j <= 9; j++) {` `            ``for` `(``int` `k = j; k <= 9; k++) {` `                ``if` `(k % j == 0) {` `                    ``dp[i][j] = (dp[i][j] + dp[i-1][k]) % MOD;` `                ``}` `            ``}` `        ``}` `    ``}`   `    ``// Compute the final answer` `    ``int` `ans = 0;` `    ``for` `(``int` `j = 1; j <= 9; j++) {` `        ``ans = (ans + dp[N][j]) % MOD;` `    ``}`   `    ``// Return the answer` `    ``return` `ans;` `}`   `// Driver Code` `int` `main()` `{` `    ``// Input 1` `    ``int` `N = 2;`   `    ``// Function Call` `    ``cout << countWays(N) << endl;`   `    ``// Input 2` `    ``int` `N1 = 3;`   `    ``// Function Call` `    ``cout << countWays(N1) << endl;`   `    ``return` `0;` `}`   `// this code is contributed by bhardwajji`

## Java

 `/*package whatever //do not write package name here */`   `// Java program for the above approach` `import` `java.util.*;`   `class` `GFG {`   `    ``static` `final` `int` `MOD = (``int``) 1e9 + ``7``;`   `    ``// Function to find number of N digits` `    ``// such that its every digit divisible` `    ``// by its previous digit` `    ``static` `int` `countWays(``int` `N) {` `        ``// DP table to store the number of` `        ``// ways for each subproblem` `        ``int``[][] dp = ``new` `int``[N + ``1``][``10``];`   `        ``// Base case` `        ``for` `(``int` `j = ``1``; j <= ``9``; j++) {` `            ``dp[``1``][j] = ``1``;` `        ``}`   `        ``// Fill the DP table` `        ``for` `(``int` `i = ``2``; i <= N; i++) {` `            ``for` `(``int` `j = ``1``; j <= ``9``; j++) {` `                ``for` `(``int` `k = j; k <= ``9``; k++) {` `                    ``if` `(k % j == ``0``) {` `                        ``dp[i][j] = (dp[i][j] + dp[i - ``1``][k]) % MOD;` `                    ``}` `                ``}` `            ``}` `        ``}`   `        ``// Compute the final answer` `        ``int` `ans = ``0``;` `        ``for` `(``int` `j = ``1``; j <= ``9``; j++) {` `            ``ans = (ans + dp[N][j]) % MOD;` `        ``}`   `        ``// Return the answer` `        ``return` `ans;` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `main (String[] args) {` `        ``// Input 1` `        ``int` `N = ``2``;`   `        ``// Function Call` `        ``System.out.println(countWays(N));`   `        ``// Input 2` `        ``int` `N1 = ``3``;`   `        ``// Function Call` `        ``System.out.println(countWays(N1));` `    ``}` `}` `// akashish__`

## Python3

 `MOD ``=` `int``(``1e9` `+` `7``)`   `# Function to find number of N digits` `# such that its every digit divisible` `# by its previous digit` `def` `countWays(N: ``int``) ``-``> ``int``:` `    ``# DP table to store the number of` `    ``# ways for each subproblem` `    ``dp ``=` `[[``0``] ``*` `10` `for` `_ ``in` `range``(N``+``1``)]`   `    ``# Base case` `    ``for` `j ``in` `range``(``1``, ``10``):` `        ``dp[``1``][j] ``=` `1`   `    ``# Fill the DP table` `    ``for` `i ``in` `range``(``2``, N``+``1``):` `        ``for` `j ``in` `range``(``1``, ``10``):` `            ``for` `k ``in` `range``(j, ``10``):` `                ``if` `k ``%` `j ``=``=` `0``:` `                    ``dp[i][j] ``=` `(dp[i][j] ``+` `dp[i``-``1``][k]) ``%` `MOD`   `    ``# Compute the final answer` `    ``ans ``=` `0` `    ``for` `j ``in` `range``(``1``, ``10``):` `        ``ans ``=` `(ans ``+` `dp[N][j]) ``%` `MOD`   `    ``# Return the answer` `    ``return` `ans`   `# Driver Code` `if` `__name__ ``=``=` `'__main__'``:` `    ``# Input 1` `    ``N ``=` `2`   `    ``# Function Call` `    ``print``(countWays(N))`   `    ``# Input 2` `    ``N1 ``=` `3`   `    ``# Function Call` `    ``print``(countWays(N1))`

## Javascript

 `const MOD = 1e9 + 7;`   `// Function to find number of N digits` `// such that its every digit divisible` `// by its previous digit` `function` `countWays(N) {` `    ``// DP table to store the number of` `    ``// ways for each subproblem` `    ``let dp = ``new` `Array(N + 1);` `    ``for` `(let i = 0; i <= N; i++) {` `        ``dp[i] = ``new` `Array(10).fill(0);` `    ``}`   `    ``// Base case` `    ``for` `(let j = 1; j <= 9; j++) {` `        ``dp[1][j] = 1;` `    ``}`   `    ``// Fill the DP table` `    ``for` `(let i = 2; i <= N; i++) {` `        ``for` `(let j = 1; j <= 9; j++) {` `            ``for` `(let k = j; k <= 9; k++) {` `                ``if` `(k % j === 0) {` `                    ``dp[i][j] = (dp[i][j] + dp[i-1][k]) % MOD;` `                ``}` `            ``}` `        ``}` `    ``}`   `    ``// Compute the final answer` `    ``let ans = 0;` `    ``for` `(let j = 1; j <= 9; j++) {` `        ``ans = (ans + dp[N][j]) % MOD;` `    ``}`   `    ``// Return the answer` `    ``return` `ans;` `}`   `// Driver Code` `let N = 2;`   `// Function Call` `console.log(countWays(N));`   `let N1 = 3;`   `// Function Call` `console.log(countWays(N1));`

Output

```23
44```

Time Complexity : O(N^2)

Auxiliary Space: O(N)

Related Articles:

My Personal Notes arrow_drop_up
Related Articles