# 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.

A **naive approach **is 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 than 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 <bits/stdc++.h>` `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[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<Vector<Integer>> v = ` `new` `Vector<Vector<Integer>>(m);` ` ` `for` `(` `int` `i = ` `0` `; i < m; i++)` ` ` `v.add(` `new` `Vector<Integer>());` ` ` `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<List<` `int` `>> v = ` `new` `List<List<` `int` `>>(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

`<?php` `// PHP 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` `function` `print_result(` `$a` `, ` `$n` `, ` `$k` `, ` `$m` `)` `{` ` ` `// Using an adjacency list like representation` ` ` `// to store numbers that lead to same` ` ` `// remainder.` ` ` `$v` `= ` `array_fill` `(0, ` `$m` `+ 1, ` `array` `());` ` ` `for` `(` `$i` `= 0; ` `$i` `< ` `$n` `; ` `$i` `++)` ` ` `{` ` ` `// stores the modulus when divided` ` ` `// by m` ` ` `$rem` `= ` `$a` `[` `$i` `] % ` `$m` `;` ` ` `array_push` `(` `$v` `[` `$rem` `], ` `$a` `[` `$i` `]);` ` ` ` ` `// If we found k elements which` ` ` `// have same remainder.` ` ` `if` `(` `count` `(` `$v` `[` `$rem` `]) == ` `$k` `)` ` ` `{` ` ` `for` `(` `$j` `= 0; ` `$j` `< ` `$k` `; ` `$j` `++)` ` ` `echo` `$v` `[` `$rem` `][` `$j` `] . ` `" "` `;` ` ` `return` `; ` ` ` `}` ` ` `}` ` ` `// If we could not find k elements` ` ` `echo` `"-1"` `;` `}` `// Driver Code` `$a` `= ` `array` `( 1, 8, 4 );` `$n` `= ` `count` `(` `$a` `);` `print_result(` `$a` `, ` `$n` `, 2, 3);` `// This code is contributed by mits` `?>` |

## Javascript

`<script>` `// JavaScript 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` `function` `print_result(a, n, k, m)` `{` ` ` `// Using an adjacency list like representation` ` ` `// to store numbers that lead to same` ` ` `// remainder.` ` ` `var` `v = Array.from(Array(m), ()=> Array());` ` ` `for` `(` `var` `i = 0; i < n; i++) {` ` ` `// stores the modulus when divided` ` ` `// by m` ` ` `var` `rem = a[i] % m;` ` ` `v[rem].push(a[i]);` ` ` ` ` `// If we found k elements which` ` ` `// have same remainder.` ` ` `if` `(v[rem].length == k)` ` ` `{` ` ` `for` `(` `var` `j = 0; j < k; j++)` ` ` `document.write( v[rem][j] + ` `" "` `);` ` ` `return` `; ` ` ` `}` ` ` `}` ` ` ` ` `// If we could not find k elements` ` ` `document.write( ` `"-1"` `);` `}` `// driver program to test the above function` `var` `a = [1, 8, 4];` `var` `n = a.length;` `print_result(a, n, 2, 3);` `</script>` |

**Output:**

1 4

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

This article is contributed by **Raja Vikramaditya**. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the **Essential Maths for CP Course** at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more, please refer **Complete Interview Preparation Course****.**