Related Articles
Check if N is divisible by a number which is composed of the digits from the set {A, B}
• Difficulty Level : Easy
• Last Updated : 05 Dec, 2018

Given three integers N, A and B, the task is to find whether N is divisible by any number that contains only A and B as it’s digits.

Examples:

Input: N = 106, a = 3, b = 5
Output: Yes
106 is divisible by 53

Input: N = 107, a = 3, b = 5
Output: No

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

Approach 1 (Recursive): An efficient solution is to make all the numbers that contains a and b as their digits using recursive function starting with the numbers a and b. If function call is fun(x) then recursively call for fun(x * 10 + a) and fun(x * 10 + b). If n is divisible by any of the number then print Yes else print No.

Below is the implementation of the above approach:

## C++

 `// CPP program to find if number N is divisible by a``// number that contains only a and b as it's digits``#include ``using` `namespace` `std;`` ` `// Function to check whether n is divisible ``// by a number whose digits are either a or b``bool` `isDivisibleRec(``int` `x, ``int` `a, ``int` `b, ``int` `n)``{``    ``// base condition``    ``if` `(x > n)``        ``return` `false``;`` ` `    ``if` `(n % x == 0)``        ``return` `true``;`` ` `    ``// recursive call``    ``return` `(isDivisibleRec(x * 10 + a, a, b, n)``            ``|| isDivisibleRec(x * 10 + b, a, b, n));``}`` ` `bool` `isDivisible(``int` `a, ``int` `b, ``int` `n)``{``   ``// Check for all numbers beginning with 'a' or 'b'``   ``return` `isDivisibleRec(a, a, b, n) || ``          ``isDivisibleRec(b, a, b, n);``}`` ` `// Driver program``int` `main()``{``    ``int` `a = 3, b = 5, n = 53;`` ` `    ``if` `(isDivisible(a, b, n))``        ``cout << ``"Yes"``;``    ``else``        ``cout << ``"No"``;`` ` `    ``return` `0;``}`

## Java

 `// Java program to find if number N is divisible by a``// number that contains only a and b as it's digits`` ` `import` `java.util.*;``class` `solution``{`` ` `// Function to check whether n is divisible ``// by a number whose digits are either a or b``static` `boolean` `isDivisibleRec(``int` `x, ``int` `a, ``int` `b, ``int` `n)``{``    ``// base condition``    ``if` `(x > n)``        ``return` `false``;`` ` `    ``if` `(n % x == ``0``)``        ``return` `true``;`` ` `    ``// recursive call``    ``return` `(isDivisibleRec(x * ``10` `+ a, a, b, n) ``            ``|| isDivisibleRec(x * ``10` `+ b, a, b, n));``}`` ` `static` `boolean` `isDivisible(``int` `a, ``int` `b, ``int` `n)``{``// Check for all numbers beginning with 'a' or 'b'``return` `isDivisibleRec(a, a, b, n) ``        ``||isDivisibleRec(b, a, b, n);``}`` ` `// Driver program``public` `static` `void` `main(String args[])``{``    ``int` `a = ``3``, b = ``5``, n = ``53``;`` ` `    ``if` `(isDivisible(a, b, n))``        ``System.out.print(``"Yes"``);``    ``else``        ``System.out.print(``"No"``);`` ` `}`` ` `}``//contributed by Arnab Kundu`

## Python 3

 `# Python 3 program to find if number N ``# is divisible by a number that contains ``# only a and b as it's digits`` ` `# Function to check whether n is divisible ``# by a number whose digits are either a or b``def` `isDivisibleRec(x, a, b, n):`` ` `    ``# base condition``    ``if` `(x > n):``        ``return` `False`` ` `    ``if` `(n ``%` `x ``=``=` `0``):``        ``return` `True`` ` `    ``# recursive call``    ``return` `(isDivisibleRec(x ``*` `10` `+` `a, a, b, n) ``or` `            ``isDivisibleRec(x ``*` `10` `+` `b, a, b, n))`` ` `def` `isDivisible(a, b, n):`` ` `    ``# Check for all numbers beginning``    ``# with 'a' or 'b'``    ``return` `(isDivisibleRec(a, a, b, n) ``or` `            ``isDivisibleRec(b, a, b, n))`` ` `# Driver Code``a ``=` `3``; b ``=` `5``; n ``=` `53``;`` ` `if` `(isDivisible(a, b, n)):``    ``print``(``"Yes"``)``else``:``    ``print``(``"No"``)`` ` `# This code is contributed ``# by Akanksha Rai`

## C#

 `// C# program to find if number N is ``// divisible by a number that contains``// only a and b as it's digits ``using` `System;`` ` `class` `GFG``{``     ` `// Function to check whether n is divisible ``// by a number whose digits are either a or b ``static` `bool` `isDivisibleRec(``int` `x, ``int` `a, ``                           ``int` `b, ``int` `n) ``{ ``    ``// base condition ``    ``if` `(x > n) ``        ``return` `false``; `` ` `    ``if` `(n % x == 0) ``        ``return` `true``; `` ` `    ``// recursive call ``    ``return` `(isDivisibleRec(x * 10 + a, a, b, n) ||``            ``isDivisibleRec(x * 10 + b, a, b, n)); ``} `` ` `static` `bool` `isDivisible(``int` `a, ``int` `b, ``int` `n) ``{ ``     ` `// Check for all numbers beginning``// with 'a' or 'b' ``return` `isDivisibleRec(a, a, b, n) || ``       ``isDivisibleRec(b, a, b, n); ``} `` ` `// Driver Code``static` `public` `void` `Main ()``{``    ``int` `a = 3, b = 5, n = 53; `` ` `    ``if` `(isDivisible(a, b, n)) ``        ``Console.WriteLine(``"Yes"``); ``    ``else``        ``Console.WriteLine(``"No"``); ``} ``} `` ` `// This code is contributed by Sachin`

## PHP

 ` ``\$n``)``        ``return` `false;`` ` `    ``if` `(``\$n` `% ``\$x` `== 0)``        ``return` `true;`` ` `    ``// recursive call``    ``return` `(isDivisibleRec(``\$x` `* 10 + ``\$a``, ``\$a``, ``\$b``, ``\$n``) ||``            ``isDivisibleRec(``\$x` `* 10 + ``\$b``, ``\$a``, ``\$b``, ``\$n``));``}`` ` `function` `isDivisible(``\$a``, ``\$b``, ``\$n``)``{``     ` `// Check for all numbers beginning ``// with 'a' or 'b'``return` `isDivisibleRec(``\$a``, ``\$a``, ``\$b``, ``\$n``) || ``       ``isDivisibleRec(``\$b``, ``\$a``, ``\$b``, ``\$n``);``}`` ` `// Driver Code``\$a` `= 3; ``\$b` `= 5; ``\$n` `= 53;`` ` `if` `(isDivisible(``\$a``, ``\$b``, ``\$n``))``    ``echo` `"Yes"``;``else``    ``echo` `"No"``;`` ` `// This code is contributed``// by Akanksha Rai`
Output:
```Yes
```

Approach 2 (Queue Based): The idea is to generate all numbers (smaller than n) containing digits a and b. For every number check if it divides n or not. How to generate all numbers smaller than n? We use queue for this. Initially we push ‘a’ and ‘b’ to the queue. Then we run a loop while front of queue is smaller than n. We pop an item one by one and for ever popped item x, we generate next numbers x*10 + a and x*10 + b and enqueue them. Time complexity of this approach is O(n)

Please refer below post for implementation of this approach.
Count of Binary Digit numbers smaller than N My Personal Notes arrow_drop_up