# Count divisors of n that have at-least one digit common with n

• Difficulty Level : Easy
• Last Updated : 28 Apr, 2021

Given a 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. ```

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

 ``

## Javascript

 ``

Output:

`3`

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