# Find two numbers made up of a given digit such that their difference is divisible by N

Given two numbers, N and M, the task is to find two numbers made up of M as all its digits such that their difference is divisible by N
Examples:

Input: N = 8, M = 2
Output: 22 222
Explanation: The difference between 222 and 22 (200) is divisible by 8

Input: N = 17, M = 6
Output: 6 66666666666666666

Approach:
In this problem, we have to find numbers consisting of only one unique digit. Let’s say M is equal to 2, then we have to find A and B from numbers like 2, 22, 222, 2222 …so on. The difference between A and B should be divisible by N. For this condition to satisfy, we have to pick A and B such that the remainder of A and B when it is divided by N, is the same.
For a digit of length N+1 length, consisting of only one unique digit M, we will have N+1 numbers. If we divide these N+1 numbers by N we will have N+1 remainders which will range from [0, N]. Since the numbers can exceed the range of integer values, we are storing remainder-length of the number as key-value pairings in a Map. Once a remainder occurs with a value already paired in the Map, the current length and the mapped lengths are the lengths of the desired numbers.

The below code is the implementation of the above approach:

## C++

 `// C++ implementation ` `// of the above approach ` ` `  `#include ` `using` `namespace` `std; ` ` `  `// Function to implement ` `// the above approach ` `void` `findNumbers(``int` `N, ``int` `M) ` `{ ` `    ``int` `m = M; ` ` `  `    ``// Hashmap to store ` `    ``// remainder-length of the ` `    ``// number as key-value pairs ` `    ``map<``int``, ``int``> remLen; ` ` `  `    ``int` `len, remainder; ` `    ``// Iterate till N + 1 length ` `    ``for` `(len = 1; len <= N + 1; ++len) { ` `        ``remainder = M % N; ` `        ``// Search remainder in the map ` `        ``if` `(remLen.find(remainder) ` `            ``== remLen.end()) ` `            ``// If remainder is not ` `            ``// already present insert ` `            ``// the length for the ` `            ``// corresponding remainder ` `            ``remLen[remainder] = len; ` `        ``else` `            ``break``; ` ` `  `        ``// Keep increasing M ` `        ``M = M * 10 + m; ` `        ``// To keep M in range of integer ` `        ``M = M % N; ` `    ``} ` `    ``// Length of one number ` `    ``// is the current Length ` `    ``int` `LenA = len; ` `    ``// Length of the other number ` `    ``// is the length paired with ` `    ``// current remainder in map ` `    ``int` `LenB = remLen[remainder]; ` ` `  `    ``for` `(``int` `i = 0; i < LenB; ++i) ` `        ``cout << m; ` `    ``cout << ``" "``; ` `    ``for` `(``int` `i = 0; i < LenA; ++i) ` `        ``cout << m; ` ` `  `    ``return``; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `N = 8, M = 2; ` ` `  `    ``findNumbers(N, M); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java implementation of the above approach ` `import` `java.util.*; ` ` `  `class` `GFG{ ` ` `  `// Function to implement ` `// the above approach ` `static` `void` `findNumbers(``int` `N, ``int` `M) ` `{ ` `    ``int` `m = M; ` ` `  `    ``// Hashmap to store ` `    ``// remainder-length of the ` `    ``// number as key-value pairs ` `    ``Map remLen = ``new` `HashMap<>(); ` ` `  `    ``int` `len, remainder = ``0``; ` `     `  `    ``// Iterate till N + 1 length ` `    ``for``(len = ``1``; len <= N + ``1``; ++len) ` `    ``{ ` `       ``remainder = M % N; ` `        `  `       ``// Search remainder in the map ` `       ``if` `(!remLen.containsKey(remainder)) ` `       ``{ ` `            `  `           ``// If remainder is not ` `           ``// already present insert ` `           ``// the length for the ` `           ``// corresponding remainder ` `           ``remLen.put(remainder, len); ` `       ``} ` `       ``else` `       ``{ ` `           ``break``; ` `       ``} ` `        `  `       ``// Keep increasing M ` `       ``M = M * ``10` `+ m; ` `        `  `       ``// To keep M in range of integer ` `       ``M = M % N; ` `    ``} ` `     `  `    ``// Length of one number ` `    ``// is the current Length ` `    ``int` `LenA = len; ` `     `  `    ``// Length of the other number ` `    ``// is the length paired with ` `    ``// current remainder in map ` `    ``int` `LenB = remLen.getOrDefault(remainder, ``0``); ` ` `  `    ``for``(``int` `i = ``0``; i < LenB; ++i) ` `       ``System.out.print(m); ` `    ``System.out.print(``" "``); ` `     `  `    ``for``(``int` `i = ``0``; i < LenA; ++i) ` `       ``System.out.print(m); ` `} ` ` `  `// Driver code ` `public` `static` `void` `main(String[] args) ` `{ ` `    ``int` `N = ``8``, M = ``2``; ` ` `  `    ``findNumbers(N, M); ` `} ` `} ` ` `  `// This code is contributed by offbeat `

## Python3

 `# Python3 implementation ` `# of the above approach ` ` `  `# Function to implement ` `# the above approach ` `def` `findNumbers(N, M): ` ` `  `    ``m ``=` `M ` ` `  `    ``# Hashmap to store ` `    ``# remainder-length of the ` `    ``# number as key-value pairs ` `    ``remLen ``=` `{} ` ` `  `    ``# Iterate till N + 1 length ` `    ``for` `len1 ``in` `range``(``1``, N ``+` `1``, ``1``): ` `        ``remainder ``=` `M ``%` `N ` `         `  `        ``# Search remainder in the map ` `        ``if` `(remLen.get(remainder) ``=``=` `None``): ` `             `  `            ``# If remainder is not ` `            ``# already present insert ` `            ``# the length for the ` `            ``# corresponding remainder ` `            ``remLen[remainder] ``=` `len1 ` `        ``else``: ` `            ``break` ` `  `        ``# Keep increasing M ` `        ``M ``=` `M ``*` `10` `+` `m ` `         `  `        ``# To keep M in range of integer ` `        ``M ``=` `M ``%` `N ` `         `  `    ``# Length of one number ` `    ``# is the current Length ` `    ``LenA ``=` `len1 ` `     `  `    ``# Length of the other number ` `    ``# is the length paired with ` `    ``# current remainder in map ` `    ``LenB ``=` `remLen[remainder] ` ` `  `    ``for` `i ``in` `range``(LenB): ` `        ``print``(m, end ``=` `"") ` `    ``print``(``" "``, end ``=` `"") ` `     `  `    ``for` `i ``in` `range``(LenA): ` `        ``print``(m, end ``=` `"") ` ` `  `    ``return` ` `  `# Driver code ` `if` `__name__ ``=``=` `'__main__'``: ` `     `  `    ``N ``=` `8` `    ``M ``=` `2` ` `  `    ``findNumbers(N, M) ` ` `  `# This code is contributed by Bhupendra_Singh `

## C#

 `// C# implementation of the above approach ` `using` `System; ` `using` `System.Collections.Generic; ` ` `  `class` `GFG{ ` ` `  `// Function to implement ` `// the above approach ` `static` `void` `findNumbers(``int` `N, ``int` `M) ` `{ ` `    ``int` `m = M; ` ` `  `    ``// To store remainder-length of  ` `    ``// the number as key-value pairs ` `    ``Dictionary<``int``,  ` `               ``int``> remLen = ``new` `Dictionary<``int``, ` `                                            ``int``>(); ` ` `  `    ``int` `len, remainder = 0; ` `     `  `    ``// Iterate till N + 1 length ` `    ``for``(len = 1; len <= N + 1; ++len) ` `    ``{ ` `        ``remainder = M % N; ` `             `  `        ``// Search remainder in the map ` `        ``if` `(!remLen.ContainsKey(remainder)) ` `        ``{ ` `                 `  `            ``// If remainder is not ` `            ``// already present insert ` `            ``// the length for the ` `            ``// corresponding remainder ` `            ``remLen.Add(remainder, len); ` `        ``} ` `        ``else` `        ``{ ` `            ``break``; ` `        ``} ` `             `  `        ``// Keep increasing M ` `        ``M = M * 10 + m; ` `             `  `        ``// To keep M in range of integer ` `        ``M = M % N; ` `    ``} ` `     `  `    ``// Length of one number ` `    ``// is the current Length ` `    ``int` `LenA = len; ` `     `  `    ``// Length of the other number ` `    ``// is the length paired with ` `    ``// current remainder in map ` `    ``int` `LenB = remLen[remainder]; ` ` `  `    ``for``(``int` `i = 0; i < LenB; ++i) ` `        ``Console.Write(m); ` `         `  `    ``Console.Write(``" "``); ` `     `  `    ``for``(``int` `i = 0; i < LenA; ++i) ` `        ``Console.Write(m); ` `} ` ` `  `// Driver code ` `public` `static` `void` `Main(String[] args) ` `{ ` `    ``int` `N = 8, M = 2; ` ` `  `    ``findNumbers(N, M); ` `} ` `} ` ` `  `// This code is contributed by Amit Katiyar `

Output:

```22 222
```

Time Complexity: O(N)
Auxiliary Space: O(1) My Personal Notes arrow_drop_up Check out this Author's contributed articles.

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.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Be the First to upvote.

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.