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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation
// of the above approach
  
#include <bits/stdc++.h>
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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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<Integer, Integer> 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

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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

chevron_right


Output: 

22 222

Time Complexity: O(N) 
Auxiliary Space: O(1)
 

competitive-programming-img




My Personal Notes arrow_drop_up

Recommended Posts:


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.