# Print k numbers where all pairs are divisible by m

Given an integer array and two numbers k and m. Print k numbers from the array, such that difference between any two pairs is divisible by m. If there are no k numbers, then print -1.

Examples:

Input: arr[] = {1, 8, 4}
k = 2
m = 3
Output: 1 4
Explanation: Difference between
1 and 4 is divisible by 3.

Input: arr[] = {1, 8, 4}
k = 3
m = 3
Output: -1
Explanation: there are only two numbers
whose difference is divisible by m, but
k is three here which is not possible,
hence we print -1.

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

A naive approach is be to iterate for every element and check with all other elements, and if the count of numbers whose difference is divisible by m is greater then equal to k, then we print those k numbers by again iterating. But this won’t be efficient enough as it runs two nested loops.
Time complexity: O(n * n)
Auxiliary space: O(1)

An efficient approach is apply a mathematical approach, where we know if (x-y) % m is equal to x%m – y%m. So if we can store all the numbers who leave the same remainder when divided by m,
And if the count of numbers which leaves the same remainder is more than k or equal to k, then we have our answer as all those numbers who leave the same remainder.

Below is the implementation of the above approach

## C++

 // CPP program to find a list of k elements from // an array such that difference between all of // them is divisible by m. #include using namespace std;    // function to generate k numbers whose difference  // is divisible by m void print_result(int a[], int n, int k, int m) {     // Using an adjacency list like representation     // to store numbers that lead to same      // remainder.     vector v[m];        for (int i = 0; i < n; i++) {            // stores the modulus when divided         // by m         int rem = a[i] % m;            v[rem].push_back(a[i]);                    // If we found k elements which         // have same remainder.         if (v[rem].size() == k)         {             for (int j = 0; j < k; j++)                  cout << v[rem][j] << " ";             return;                      }      }          // If we could not find k elements     cout << "-1"; }    // driver program to test the above function int main() {     int a[] = { 1, 8, 4 };     int n = sizeof(a) / sizeof(a[0]);     print_result(a, n, 2, 3);     return 0; }

## Java

 // Java program to find a list of k elements from // an array such that difference between all of // them is divisible by m. import java.util.*; class GFG  {    // function to generate k numbers whose difference  // is divisible by m static void print_result(int a[], int n,                           int k, int m) {     // Using an adjacency list like representation     // to store numbers that lead to same      // remainder.     Vector> v = new Vector>(m);     for(int i = 0; i < m; i++)          v.add(new Vector());        for (int i = 0; i < n; i++)     {            // stores the modulus when divided         // by m         int rem = a[i] % m;            v.get(rem).add(a[i]);                    // If we found k elements which         // have same remainder.         if (v.get(rem).size() == k)         {             for (int j = 0; j < k; j++)                  System.out.print(v.get(rem).get(j) + " ");             return;                      }      }            // If we could not find k elements     System.out.print("-1"); }    // Driver Code public static void main(String[] args)  {     int a[] = { 1, 8, 4 };     int n = a.length;     print_result(a, n, 2, 3); } }    // This code is contributed by 29AjayKumar

## Python3

 # Python3 program to find a list of k elements from # an array such that difference between all of # them is divisible by m.    # function to generate k numbers whose difference # is divisible by m def print_result(a, n, k, m):        # Using an adjacency list like representation     # to store numbers that lead to same     # remainder.     v = [[] for i in range(m)]        for i in range(0, n):            # stores the modulus when divided         # by m         rem = a[i] % m            v[rem].append(a[i])            # If we found k elements which         # have same remainder.         if(len(v[rem]) == k):                for j in range(0, k):                 print(v[rem][j], end=" ")             return        # If we could not find k elements     print(-1)    # driver program to test the above function if __name__=='__main__':     a = [1, 8, 4]     n = len(a)     print_result(a, n, 2, 3)    # This code is contributed by # Sanjit_Prasad

## C#

 // C# program to find a list of k elements from // an array such that difference between all of // them is divisible by m. using System; using System.Collections.Generic;    class GFG  {    // function to generate k numbers whose difference  // is divisible by m static void print_result(int []a, int n,                           int k, int m) {     // Using an adjacency list like representation     // to store numbers that lead to same      // remainder.     List> v = new List>(m);     for(int i = 0; i < m; i++)          v.Add(new List());        for (int i = 0; i < n; i++)     {            // stores the modulus when divided         // by m         int rem = a[i] % m;            v[rem].Add(a[i]);                    // If we found k elements which         // have same remainder.         if (v[rem].Count == k)         {             for (int j = 0; j < k; j++)                  Console.Write(v[rem][j] + " ");             return;                      }      }            // If we could not find k elements     Console.Write("-1"); }    // Driver Code public static void Main(String[] args)  {     int []a = { 1, 8, 4 };     int n = a.Length;     print_result(a, n, 2, 3); } }    // This code is contributed by PrinciRaj1992

## PHP



Output:

1 4

Time complexity: O(n)
Auxiliary Space: O(m)