# 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<``int``> 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); ` `    ``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<``int``>()); ` ` `  `    ``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)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up

Article Tags :

Be the First to upvote.

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