# Count N-digit numbers such that every position is divisible by the digit at that position

• Last Updated : 22 Jul, 2021

Given a positive integer N, the task is to count the number of N-digit numbers such that every index (1-based indexing) in the number is divisible by the digit occurring at that index. Since the court can be very large, print it modulo 109 + 7.

Examples:

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

Input: N = 2
Output: 2
Explanation: The numbers 11 and 12 are the only 2-digit numbers satisfying the condition.

Input: N = 5
Output: 24

Naive Approach: The simplest approach to solve the problem is to generate all possible N-digit numbers and for each such number, check if all its digits satisfy the required condition or not.

Time Complexity: O(10N*N)
Auxiliary Space: O(1)

Efficient Approach: To optimize the above approach, the idea is to observe the fact that for every position, there are 9 possible options from 1 to 9. Check for every possible option and find the result.
Follow the steps below to solve this problem:

• Initialize the variable ans as 1 to store the answer.
• Iterate over the range [1, N] using the variable index and perform the following tasks:
• Initialize the variable, say choices as 0, to store the number of options for that particular index.
• Iterate over the range [1, 9] using a variable digit and perform the following tasks:
• If index%digit is equal to 0, then increase the value of choices by 1.
• Set the value of ans as (ans*1LL*choices)%mod.
• After performing the above steps, print the value of ans as the answer.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;` `const` `int` `mod = 1e9 + 7;` `// Function to count N-digit numbers``// such that each position is divisible``// by the digit occurring at that position``void` `countOfNumbers(``int` `N)``{``    ``// Stores the answer.``    ``int` `ans = 1;` `    ``// Iterate from indices 1 to N``    ``for` `(``int` `index = 1; index <= N; ++index) {` `        ``// Stores count of digits that can``        ``// be placed at the current index``        ``int` `choices = 0;` `        ``// Iterate from digit 1 to 9``        ``for` `(``int` `digit = 1; digit <= 9; ++digit) {` `            ``// If index is divisible by digit``            ``if` `(index % digit == 0) {``                ``++choices;``            ``}``        ``}` `        ``// Multiply answer with possible choices``        ``ans = (ans * 1LL * choices) % mod;``    ``}` `    ``cout << ans << endl;``}` `// Driver Code``int` `main()``{``    ``// Given Input``    ``int` `N = 5;` `    ``// Function call``    ``countOfNumbers(N);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.lang.*;``import` `java.util.*;`` ` `class` `GFG{` `static` `int` `mod = ``1000000007``;``  ` `// Function to count N-digit numbers``// such that each position is divisible``// by the digit occurring at that position``static` `void` `countOfNumbers(``int` `N)``{``    ` `    ``// Stores the answer.``    ``int` `ans = ``1``;` `    ``// Iterate from indices 1 to N``    ``for``(``int` `index = ``1``; index <= N; ++index)``    ``{``        ` `        ``// Stores count of digits that can``        ``// be placed at the current index``        ``int` `choices = ``0``;` `        ``// Iterate from digit 1 to 9``        ``for``(``int` `digit = ``1``; digit <= ``9``; ++digit)``        ``{``            ` `            ``// If index is divisible by digit``            ``if` `(index % digit == ``0``)``            ``{``                ``++choices;``            ``}``        ``}` `        ``// Multiply answer with possible choices``        ``ans = (ans * choices) % mod;``    ``}``    ``System.out.println(ans);``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ` `    ``// Given Input``    ``int` `N = ``5``;` `    ``// Function call``    ``countOfNumbers(N);``}``}` `// This code is contributed by shivanisinghss2110`

## Python3

 `# python program for the above approach``mod ``=` `1000000000` `+` `7` `# Function to count N-digit numbers``# such that each position is divisible``# by the digit occurring at that position``def` `countOfNumbers(N):``  ` `    ``# Stores the answer.``    ``ans ``=` `1``    ` `    ``# Iterate from indices 1 to N``    ``for` `index ``in` `range``(``1``, N ``+` `1``):``      ` `        ``# Stores count of digits that can``        ``# be placed at the current index``        ``choices ``=` `0``        ` `        ``# Iterate from digit 1 to 9``        ``for` `digit ``in` `range``(``1``, ``10``):``          ` `            ``# If index is divisible by digit``            ``if` `(index ``%` `digit ``=``=` `0``):``                ``choices ``+``=` `1` `        ``# Multiply answer with possible choices``        ``ans ``=` `(ans ``*` `choices) ``%` `mod``    ``print``(ans)` `# Driver Code` `# Given Input``N ``=` `5` `# Function call``countOfNumbers(N)` `# This code is contributed by amreshkumar3.`

## C#

 `// C# program for the above approach``using` `System;``using` `System.Collections.Generic;` `class` `GFG{` `  ``static` `int` `mod = 1000000007;``  ` `// Function to count N-digit numbers``// such that each position is divisible``// by the digit occurring at that position``static` `void` `countOfNumbers(``int` `N)``{``    ``// Stores the answer.``    ``int` `ans = 1;` `    ``// Iterate from indices 1 to N``    ``for` `(``int` `index = 1; index <= N; ++index) {` `        ``// Stores count of digits that can``        ``// be placed at the current index``        ``int` `choices = 0;` `        ``// Iterate from digit 1 to 9``        ``for` `(``int` `digit = 1; digit <= 9; ++digit) {` `            ``// If index is divisible by digit``            ``if` `(index % digit == 0) {``                ``++choices;``            ``}``        ``}` `        ``// Multiply answer with possible choices``        ``ans = (ans * choices) % mod;``    ``}` `    ``Console.Write(ans);``}` `// Driver Code``public` `static` `void` `Main()``{``    ``// Given Input``    ``int` `N = 5;` `    ``// Function call``    ``countOfNumbers(N);``}``}` `// This code is contributed by bgangwar59.`

## Javascript

 ``
Output:
`24`

Time Complexity: O(10 * N)
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up