Related Articles
Count divisors of n that have at-least one digit common with n
• Difficulty Level : Easy
• Last Updated : 30 Jul, 2018

Given an number n, find the number of divisors whose at least one digit in the decimal representation matches with the number n.

Examples:

```Input : n = 10
Output: 2
Explanation: numbers are 1 and 10, 1 and 10
both have a nimbus of 1 digit common with n = 10.

Input : n = 15
Output: 3
Explanation: the numbers are 1, 5, 15, all of them
have a minimum of 1 digit common.
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

A naive approach is to iterate from 1 to n and check for all the divisors, and use hashing to determine if any of the digits match with n or not.
Time complexity: O(n)
Auxiliary space: O(1)

An efficient approach is to iterate from 1 to sqrt(n) and check for all the divisors i and n/i, if both are different, we check if there is any match for i and n/i, if yes we simply add 1 to the answer. We use hashing to store if a number is present or not.

Below is the implementation of the above approach

## C++

 `// C++ program to count divisors of n that have at least ` `// one digit common with n ` `#include ` `using` `namespace` `std; ` ` `  `// function to return true if any digit of m is  ` `// present in hash[]. ` `bool` `isDigitPresent(``int` `m, ``bool` `hash[]) ` `{ ` `    ``// check till last digit ` `    ``while` `(m) { ` ` `  `        ``// if number is also present in original number  ` `        ``// then return true ` `        ``if` `(hash[m % 10]) ` `            ``return` `true``; ` `        ``m = m / 10; ` `    ``} ` ` `  `    ``// if no number matches then return 1 ` `    ``return` `false``; ` `} ` ` `  `// Count the no of divisors that have at least 1 digits ` `// same ` `int` `countDivisibles(``int` `n) ` `{ ` `    ``// Store digits present in n in a hash[] ` `    ``bool` `hash = { 0 }; ` `    ``int` `m = n;  ` `    ``while` `(m) { ` ` `  `        ``// marks that the number is present ` `        ``hash[m % 10] = ``true``;  ` ` `  `        ``// last digit removed  ` `        ``m = m / 10;  ` `    ``} ` ` `  `    ``// loop to traverse from 1 to sqrt(n) to  ` `    ``// count divisors ` `    ``int` `ans = 0; ` `    ``for` `(``int` `i = 1; i <= ``sqrt``(n); i++) { ` ` `  `        ``// if i is the factor ` `        ``if` `(n % i == 0) { ` ` `  `            ``// call the function to check if any ` `            ``// digits match or not ` `            ``if` `(isDigitPresent(i, hash)) ` `                ``ans++; ` ` `  `            ``if` `(n / i != i) { ` ` `  `                ``// if n/i != i then a different number,  ` `                ``// then check it also ` `                ``if` `(isDigitPresent(n/i, hash)) ` `                ``ans++; ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``// return the answer ` `    ``return` `ans; ` `} ` ` `  `// driver program to test the above function ` `int` `main() ` `{ ` `    ``int` `n = 15; ` `    ``cout << countDivisibles(n); ` `    ``return` `0; ` `} `

## Java

 `// Java program to count divisors of n that  ` `// have at least one digit common with n ` `class` `GFG { ` `     `  `    ``// function to return true if any digit ` `    ``// of m is present in hash[]. ` `    ``static` `boolean` `isDigitPresent(``int` `m,  ` `                            ``boolean` `hash[]) ` `    ``{ ` `         `  `        ``// check till last digit ` `        ``while` `(m > ``0``) { ` `     `  `            ``// if number is also present  ` `            ``// in original number then  ` `            ``// return true ` `            ``if` `(hash[m % ``10``]) ` `                ``return` `true``; ` `            ``m = m / ``10``; ` `        ``} ` `     `  `        ``// if no number matches then  ` `        ``// return 1 ` `        ``return` `false``; ` `    ``} ` `     `  `    ``// Count the no of divisors that  ` `    ``// have at least 1 digits same ` `    ``static` `int` `countDivisibles(``int` `n) ` `    ``{ ` `         `  `        ``// Store digits present in n  ` `        ``// in a hash[] ` `        ``boolean` `hash[] = ``new` `boolean``[``10``]; ` `        ``int` `m = n;  ` `        ``while` `(m > ``0``) { ` `     `  `            ``// marks that the number  ` `            ``// is present ` `            ``hash[m % ``10``] = ``true``;  ` `     `  `            ``// last digit removed  ` `            ``m = m / ``10``;  ` `        ``} ` `     `  `        ``// loop to traverse from 1 to ` `        ``// sqrt(n) to count divisors ` `        ``int` `ans = ``0``; ` `        ``for` `(``int` `i = ``1``; i <= Math.sqrt(n); ` `                                    ``i++) ` `        ``{ ` `     `  `            ``// if i is the factor ` `            ``if` `(n % i == ``0``) { ` `     `  `                ``// call the function to  ` `                ``// check if any digits  ` `                ``// match or not ` `                ``if` `(isDigitPresent(i, hash)) ` `                    ``ans++; ` `     `  `                ``if` `(n / i != i) { ` `     `  `                    ``// if n/i != i then a  ` `                    ``// different number,  ` `                    ``// then check it also ` `                    ``if` `(isDigitPresent(n/i, hash)) ` `                        ``ans++; ` `                ``} ` `            ``} ` `        ``} ` `     `  `        ``// return the answer ` `        ``return` `ans; ` `    ``} ` `     `  `    ``//driver code ` `    ``public` `static` `void` `main (String[] args) ` `    ``{ ` `        ``int` `n = ``15``; ` `         `  `        ``System.out.print(countDivisibles(n)); ` `    ``} ` `} ` ` `  `// This code is contributed by Anant Agarwal. `

## Python3

 `# Python3 program to count divisors ` `# of n that have at least ` `# one digit common with n ` `import` `math ` ` `  `# Function to return true if any   ` `# digit of m is present in hash[]. ` `def` `isDigitPresent(m, ``Hash``): ` ` `  `    ``# check till last digit ` `    ``while` `(m):  ` ` `  `        ``# if number is also present in original   ` `        ``# number then return true ` `        ``if` `(``Hash``[m ``%` `10``]): ` `            ``return` `True` `        ``m ``=` `m ``/``/` `10` ` `  `    ``# if no number matches then return 1 ` `    ``return` `False` ` `  `# Count the no of divisors that  ` `# have at least 1 digits same ` `def` `countDivisibles(n): ` ` `  `    ``# Store digits present in n in a hash[] ` `    ``Hash` `=` `[``False` `for` `i ``in` `range``(``10``)] ` `    ``m ``=` `n ` `    ``while` `(m):  ` ` `  `        ``# marks that the number is present ` `        ``Hash``[m ``%` `10``] ``=` `True` ` `  `        ``# last digit removed  ` `        ``m ``=` `m ``/``/` `10` `     `  ` `  `    ``# loop to traverse from 1 to sqrt(n) to  ` `    ``# count divisors ` `    ``ans ``=` `0` `    ``for` `i ``in` `range``(``1``, ``int``(math.sqrt(n)) ``+` `1``):  ` ` `  `        ``# if i is the factor ` `        ``if` `(n ``%` `i ``=``=` `0``):  ` ` `  `            ``# call the function to check if any ` `            ``# digits match or not ` `            ``if` `(isDigitPresent(i, ``Hash``)): ` `                ``ans ``+``=` `1` ` `  `            ``if` `(n ``/``/` `i !``=` `i):  ` ` `  `                ``# if n/i != i then a different number,  ` `                ``# then check it also ` `                ``if` `(isDigitPresent(n ``/``/` `i, ``Hash``)): ` `                    ``ans ``+``=` `1` ` `  `    ``# return the answer ` `    ``return` `ans ` ` `  `# Driver Code ` `n ``=` `15` `print``(countDivisibles(n)) ` ` `  `# This code is contributed by Anant Agarwal. `

## C#

 `// Program to count divisors of ` `// n that have at least one digit ` `// common with n ` `using` `System; ` ` `  `class` `GFG { ` ` `  `    ``// function to return true if ` `    ``// any digit of m is present ` `    ``// in hash[]. ` `    ``static` `bool` `isDigitPresent(``int` `m, ``bool``[] hash) ` `    ``{ ` `        ``// check till last digit ` `        ``while` `(m > 0) { ` ` `  `            ``// if number is also present in the ` `            ``// original number then return true ` `            ``if` `(hash[m % 10]) ` `                ``return` `true``; ` `            ``m = m / 10; ` `        ``} ` ` `  `        ``// if no number matches then return 1 ` `        ``return` `false``; ` `    ``} ` ` `  `    ``// Count the no of divisors that have ` `    ``// at least 1 digits same ` `    ``static` `int` `countDivisibles(``int` `n) ` `    ``{ ` `        ``// Store digits present in n in a hash[] ` `        ``bool``[] hash = ``new` `bool``; ` `        ``int` `m = n; ` `        ``while` `(m > 0) { ` ` `  `            ``// marks that the number is present ` `            ``hash[m % 10] = ``true``; ` ` `  `            ``// last digit removed ` `            ``m = m / 10; ` `        ``} ` ` `  `        ``// loop to traverse from 1 to sqrt(n) to ` `        ``// count divisors ` `        ``int` `ans = 0; ` `        ``for` `(``int` `i = 1; i <= Math.Sqrt(n); i++) { ` ` `  `            ``// if i is the factor ` `            ``if` `(n % i == 0) { ` ` `  `                ``// call the function to check if any ` `                ``// digits match or not ` `                ``if` `(isDigitPresent(i, hash)) ` `                    ``ans++; ` ` `  `                ``if` `(n / i != i) { ` ` `  `                    ``// if n/i != i then a different number, ` `                    ``// then check it also ` `                    ``if` `(isDigitPresent(n / i, hash)) ` `                        ``ans++; ` `                ``} ` `            ``} ` `        ``} ` ` `  `        ``// return the answer ` `        ``return` `ans; ` `    ``} ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `Main() ` `    ``{ ` `        ``int` `n = 15; ` `        ``Console.Write(countDivisibles(n)); ` `    ``} ` `} ` ` `  `// This code is contributed by Anant Agarwal. `

## PHP

 ` `

Output:

```3
```

Time complexity: O(sqrt n)
Auxiliary Space: O(1)