Related Articles
Count digits in given number N which divide N
• Difficulty Level : Easy
• Last Updated : 18 Nov, 2019

Given a number N which may be 10^5 digits long, the task is to count all the digits in N which divide N. Divisibility by 0 is not allowed. If any digit in N which is repeated divides N, then all repetitions of that digit should be counted i. e., N = 122324, here 2 divides N and it appears 3 times. So count for digit 2 will be 3.

Examples:

```Input  : N = "35"
Output : 1
There are two digits in N and 1 of them
(5)divides it.

Input  : N = "122324"
Output : 5
N is divisible by 1, 2 and 4
```

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

How to check divisibility of a digit for large N stored as string?
The idea is to use distributive property of mod operation.
(x+y)%a = ((x%a) + (y%a)) % a.

```// This function returns true if digit divides N,
// else false
bool divisible(string N, int digit)
{
int ans = 0;
for (int i = 0; i < N.length(); i++)
{
// (N[i]-'0') gives the digit value and
// form the number
ans  = (ans*10 + (N[i]-'0'));

// We use distributive property of mod here.
ans %= digit;
}
return (ans == 0);
}```

A simple solution for this problem is to read number in string form and one by one check divisibility by each digit which appears in N. Time complexity for this approach will be O(N2).

An efficient solution for this problem is to use an extra array divide[] of size 10. Since we have only 10 digits so run a loop from 1 to 9 and check divisibility of N with each digit from 1 to 9. If any digit divides N then mark true in divide[] array at digit as index. Now traverse the number string and increment result if divide[i] is true for current digit i.

## C++

 `// C++ program to find number of digits in N that ` `// divide N. ` `#include ` `using` `namespace` `std; ` ` `  `// Utility function to check divisibility by digit ` `bool` `divisible(string N, ``int` `digit) ` `{ ` `    ``int` `ans = 0; ` `    ``for` `(``int` `i = 0; i < N.length(); i++) ` `    ``{ ` `        ``// (N[i]-'0') gives the digit value and ` `        ``// form the number ` `        ``ans  = (ans*10 + (N[i]-``'0'``)); ` `        ``ans %= digit; ` `    ``} ` `    ``return` `(ans == 0); ` `} ` ` `  `// Function to count digits which appears in N and ` `// divide N ` `// divide[10]  --> array which tells that particular ` `//                 digit divides N or not ` `// count[10]   --> counts frequency of digits which ` `//                 divide N ` `int` `allDigits(string N) ` `{ ` `    ``// We initialize all digits of N as not divisible ` `    ``// by N. ` `    ``bool` `divide[10] = {``false``}; ` `    ``divide[1] = ``true``;  ``// 1 divides all numbers ` ` `  `    ``// start checking divisibility of N by digits 2 to 9 ` `    ``for` `(``int` `digit=2; digit<=9; digit++) ` `    ``{ ` `        ``// if digit divides N then mark it as true ` `        ``if` `(divisible(N, digit)) ` `            ``divide[digit] = ``true``; ` `    ``} ` ` `  `    ``// Now traverse the number string to find and increment ` `    ``// result whenever a digit divides N. ` `    ``int` `result = 0; ` `    ``for` `(``int` `i=0; i

## Java

 `// Java program to find number of digits in N that ` `// divide N. ` `import` `java.util.*; ` ` `  `class` `solution ` `{ ` ` `  `// Utility function to check divisibility by digit ` `static` `boolean` `divisible(String N, ``int` `digit) ` `{ ` `    ``int` `ans = ``0``; ` `    ``for` `(``int` `i = ``0``; i < N.length(); i++) ` `    ``{ ` `        ``// (N[i]-'0') gives the digit value and ` `        ``// form the number ` `        ``ans = (ans*``10` `+ (N.charAt(i)-``'0'``)); ` `        ``ans %= digit; ` `    ``} ` `    ``return` `(ans == ``0``); ` `} ` ` `  `// Function to count digits which appears in N and ` `// divide N ` `// divide[10] --> array which tells that particular ` `//                 digit divides N or not ` `// count[10] --> counts frequency of digits which ` `//                 divide N ` `static` `int` `allDigits(String N) ` `{ ` `    ``// We initialize all digits of N as not divisible ` `    ``// by N. ` `    ``Boolean[] divide = ``new` `Boolean[``10``]; ` `    ``Arrays.fill(divide, Boolean.FALSE); ` `    ``divide[``1``] = ``true``; ``// 1 divides all numbers ` ` `  `    ``// start checking divisibility of N by digits 2 to 9 ` `    ``for` `(``int` `digit=``2``; digit<=``9``; digit++) ` `    ``{ ` `        ``// if digit divides N then mark it as true ` `        ``if` `(divisible(N, digit)) ` `            ``divide[digit] = ``true``; ` `    ``} ` ` `  `    ``// Now traverse the number string to find and increment ` `    ``// result whenever a digit divides N. ` `    ``int` `result = ``0``; ` `    ``for` `(``int` `i=``0``; i

## Python3

 `# Python3 program to find number of  ` `# digits in N that divide N.  ` ` `  `# Utility function to check  ` `# divisibility by digit  ` `def` `divisible(N, digit):  ` `  `  `    ``ans ``=` `0``;  ` `    ``for` `i ``in` `range``(``len``(N)):  ` `        ``# (N[i]-'0') gives the digit  ` `        ``# value and form the number  ` `        ``ans ``=` `(ans ``*` `10` `+` `(``ord``(N[i]) ``-` `ord``(``'0'``)));  ` `        ``ans ``%``=` `digit;  ` `    ``return` `(ans ``=``=` `0``);  ` ` `  `# Function to count digits which  ` `# appears in N and divide N  ` `# divide[10] --> array which tells  ` `# that particular digit divides N or not  ` `# count[10] --> counts frequency of  ` `#                 digits which divide N  ` `def` `allDigits(N):  ` `  `  `    ``# We initialize all digits of N  ` `    ``# as not divisible by N.  ` `    ``divide ``=``[``False``]``*``10``;  ` `    ``divide[``1``] ``=` `True``; ``# 1 divides all numbers  ` ` `  `    ``# start checking divisibility of  ` `    ``# N by digits 2 to 9  ` `    ``for` `digit ``in` `range``(``2``,``10``):  ` `        ``# if digit divides N then  ` `        ``# mark it as true  ` `        ``if` `(divisible(N, digit)):  ` `            ``divide[digit] ``=` `True``;  ` ` `  `    ``# Now traverse the number string to  ` `    ``# find and increment result whenever  ` `    ``# a digit divides N.  ` `    ``result ``=` `0``;  ` `    ``for` `i ``in` `range``(``len``(N)):  ` `      `  `        ``if` `(divide[(``ord``(N[i]) ``-` `ord``(``'0'``))] ``=``=` `True``):  ` `            ``result``+``=``1``;  ` ` `  `    ``return` `result;  ` ` `  `# Driver Code  ` `N ``=` `"122324"``;  ` `print``(allDigits(N));  ` ` `  `# This code is contributed by mits  `

## C#

 `// C# program to find number of digits  ` `// in N that divide N. ` `using` `System; ` ` `  `class` `GFG { ` `     `  `// Utility function to  ` `// check divisibility by digit ` `static` `bool` `divisible(``string` `N, ``int` `digit) ` `{ ` `    ``int` `ans = 0; ` `    ``for` `(``int` `i = 0; i < N.Length; i++) ` `    ``{ ` `         `  `        ``// (N[i]-'0') gives the digit value and ` `        ``// form the number ` `        ``ans = (ans * 10 + (N[i] - ``'0'``)); ` `        ``ans %= digit; ` `    ``} ` `    ``return` `(ans == 0); ` `} ` ` `  `// Function to count digits which  ` `// appears in N and divide N ` `// divide[10] --> array which  ` `// tells that particular ` `// digit divides N or not ` `// count[10] --> counts  ` `// frequency of digits which ` `// divide N ` `static` `int` `allDigits(``string` `N) ` `{ ` `     `  `    ``// We initialize all digits ` `    ``// of N as not divisible by N ` `    ``bool``[] divide = ``new` `bool``[10]; ` `     `  `    ``for` `(``int` `i = 0; i < divide.Length; i++)  ` `    ``{ ` `        ``divide[i] = ``false``; ` `    ``} ` `     `  `    ``// 1 divides all numbers ` `    ``divide[1] = ``true``;  ` ` `  `    ``// start checking divisibility ` `    ``// of N by digits 2 to 9 ` `    ``for` `(``int` `digit = 2; digit <= 9; digit++) ` `    ``{ ` `         `  `        ``// if digit divides N  ` `        ``// then mark it as true ` `        ``if` `(divisible(N, digit)) ` `            ``divide[digit] = ``true``; ` `    ``} ` ` `  `    ``// Now traverse the number ` `    ``// string to find and increment ` `    ``// result whenever a digit divides N. ` `    ``int` `result = 0; ` `     `  `    ``for` `(``int` `i = 0; i < N.Length; i++) ` `    ``{ ` `        ``if` `(divide[N[i] - ``'0'``] == ``true``) ` `            ``result++; ` `    ``} ` ` `  `    ``return` `result; ` `} ` ` `  `// Driver Code ` `public` `static` `void` `Main() ` `{ ` `    ``string` `N = ``"122324"``; ` `    ``Console.Write(allDigits(N)); ` `} ` `} ` ` `  `// This code is contributed  ` `// by Akanksha Rai(Abby_akku) `

## PHP

 ` array which tells  ` `// that particular digit divides N or not ` `// count[10] --> counts frequency of  ` `//                 digits which divide N ` `function` `allDigits(``\$N``) ` `{ ` `    ``// We initialize all digits of N  ` `    ``// as not divisible by N. ` `    ``\$divide` `= ``array_fill``(0, 10, false); ` `    ``\$divide``[1] = true; ``// 1 divides all numbers ` ` `  `    ``// start checking divisibility of ` `    ``// N by digits 2 to 9 ` `    ``for` `(``\$digit` `= 2; ``\$digit` `<= 9; ``\$digit``++) ` `    ``{ ` `        ``// if digit divides N then ` `        ``// mark it as true ` `        ``if` `(divisible(``\$N``, ``\$digit``)) ` `            ``\$divide``[``\$digit``] = true; ` `    ``} ` ` `  `    ``// Now traverse the number string to  ` `    ``// find and increment result whenever ` `    ``// a digit divides N. ` `    ``\$result` `= 0; ` `    ``for` `(``\$i` `= 0; ``\$i` `< ``strlen``(``\$N``); ``\$i``++) ` `    ``{ ` `        ``if` `(``\$divide``[(int)(``\$N``[``\$i``] - ``'0'``)] == true) ` `            ``\$result``++; ` `    ``} ` ` `  `    ``return` `\$result``; ` `} ` ` `  `// Driver Code ` `\$N` `= ``"122324"``; ` `echo` `allDigits(``\$N``); ` ` `  `// This code is contributed by mits ` `?> `

Output :

`5`

Time Complexity: O(n)
Auxiliary space: O(1)

This article is contributed by Shashank Mishra ( Gullu ). If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.