Sort elements by modulo with K
Last Updated :
19 Dec, 2022
Given an array, arr[] of integers and an integer K. The task is to sort the elements of the given array in the increasing order of their modulo with K. If two numbers have the same remainder then the smaller number should come first.
Examples:
Input: arr[] = {10, 3, 2, 6, 12}, K = 4
Output: 12 2 6 10 3
{12, 2, 6, 10, 3} is the required sorted order as the modulo
of these elements with K = 4 is {0, 2, 2, 2, 3}.
Input: arr[] = {3, 4, 5, 10, 11, 1}, K = 3
Output: 3 1 4 10 5 11
Approach:
- Create K empty vectors.
- Traverse the array from left to right and update the vectors such that the ith vector contains the elements that give i as the remainder when divided by K.
- Sort all the vectors separately as all the elements that give the same modulo value with K have to be sorted in ascending.
- Now, starting from the first vector to the last vector and going from left to right in the vectors will give the elements in the required sorted order.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
void printArr(int arr[], int n)
{
for (int i = 0; i < n; i++)
cout << arr[i] << " ";
}
void sortWithRemainder(int arr[], int n, int k)
{
vector<int> v[k];
for (int i = 0; i < n; i++) {
v[arr[i] % k].push_back(arr[i]);
}
for (int i = 0; i < k; i++)
sort(v[i].begin(), v[i].end());
int j = 0;
for (int i = 0; i < k; i++) {
for (vector<int>::iterator it = v[i].begin();
it != v[i].end(); it++) {
arr[j] = *it;
j++;
}
}
printArr(arr, n);
}
int main()
{
int arr[] = { 10, 7, 2, 6, 12, 3, 33, 46 };
int n = sizeof(arr) / sizeof(arr[0]);
int k = 4;
sortWithRemainder(arr, n, k);
return 0;
}
|
Java
import java.util.*;
class GFG{
static void printArr(int[] arr, int n)
{
for(int i = 0; i < n; i++)
System.out.print(arr[i] + " ");
}
static void sortWithRemainder(int[] arr,
int n, int k)
{
ArrayList<
ArrayList<Integer>> v = new ArrayList<
ArrayList<Integer>>(k);
for(int i = 0; i < k; i++)
v.add(new ArrayList<Integer>());
for(int i = 0; i < n; i++)
{
int t = arr[i] % k;
v.get(t).add(arr[i]);
}
for(int i = 0; i < k; i++)
{
Collections.sort(v.get(i));
}
int j = 0;
for(int i = 0; i < k; i++)
{
for(int x : v.get(i))
{
arr[j] = x;
j++;
}
}
printArr(arr, n);
}
public static void main(String[] args)
{
int[] arr = { 10, 7, 2, 6,
12, 3, 33, 46 };
int n = arr.length;
int k = 4;
sortWithRemainder(arr, n, k);
}
}
|
Python3
def printArr(arr, n):
for i in range(n):
print(arr[i], end = ' ')
def sortWithRemainder(arr, n, k):
v = [[] for i in range(k)]
for i in range(n):
v[arr[i] % k].append(arr[i])
for i in range(k):
v[i].sort()
j = 0
for i in range(k):
for it in v[i]:
arr[j] = it
j += 1
printArr(arr, n)
if __name__=='__main__':
arr = [ 10, 7, 2, 6, 12, 3, 33, 46 ]
n = len(arr)
k = 4
sortWithRemainder(arr, n, k)
|
C#
using System;
using System.Collections;
class GFG{
static void printArr(int []arr,
int n)
{
for (int i = 0; i < n; i++)
Console.Write(arr[i] + " ");
}
static void sortWithRemainder(int []arr,
int n, int k)
{
ArrayList []v = new ArrayList[k];
for(int i = 0; i < k; i++)
{
v[i] = new ArrayList();
}
for (int i = 0; i < n; i++)
{
v[arr[i] % k].Add(arr[i]);
}
for (int i = 0; i < k; i++)
{
v[i].Sort();
}
int j = 0;
for (int i = 0; i < k; i++)
{
foreach(int x in v[i])
{
arr[j] = x;
j++;
}
}
printArr(arr, n);
}
public static void Main(string[] args)
{
int []arr = {10, 7, 2, 6,
12, 3, 33, 46};
int n = arr.Length;
int k = 4;
sortWithRemainder(arr, n, k);
}
}
|
Javascript
<script>
function printArr(arr, n)
{
for (let i = 0; i < n; i++)
document.write(arr[i] + " ");
}
function sortWithRemainder(arr, n, k)
{
let v = new Array();
for (let i = 0; i < k; i++)
{
v.push([])
}
for (let i = 0; i < n; i++) {
v[arr[i] % k].push(arr[i]);
}
for (let i = 0; i < k; i++)
v[i].sort((a, b) => a - b);
console.log(v)
let j = 0;
for (let i = 0; i < k; i++) {
for (let it of v[i]) {
arr[j] = it;
j++;
}
}
printArr(arr, n);
}
let arr = [10, 7, 2, 6, 12, 3, 33, 46];
let n = arr.length;
let k = 4;
sortWithRemainder(arr, n, k);
</script>
|
Output
12 33 2 6 10 46 3 7
Time Complexity: O(nlogn)
Auxiliary Space: O(k), where k is a given integer.
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...