# Sort elements of array whose modulo with K yields P

• Difficulty Level : Basic
• Last Updated : 08 Sep, 2022

Given an array of integers and a number K. The task is to sort only those elements of the array which yields remainder P upon division by K . Sorting must be done at their relative positions only without affecting any other elements.

Examples

Input : arr[] = {10, 3, 2, 6, 12}, K = 4, P = 2
Output : 2 3 6 10 12

Input : arr[] = {3, 4, 5, 10, 11, 1}, K = 3, P = 1
Output : 3 1 5 4 11 10

Approach:

• Initialise two empty vectors.
• Traverse the array, from left to right and check modulo of each element with K.
• In first vector, insert the index of all elements which yields remainder P.
• In second vector, insert the elements which yields remainder P.
• Sort the second vector.
• Now, we have the index of all required elements and also all of the required elements in sorted order.
• So, insert the elements of the second vector into the array at the indices present in first vector one by one.

Below is the implementation of the above approach:

## C++

 `// C++ program for sorting array elements``// whose modulo with K yields P` `#include ``using` `namespace` `std;` `// Function to sort elements``// whose modulo with K yields P``void` `sortWithRemainderP(``int` `arr[], ``int` `n, ``int` `k, ``int` `p)``{``    ``// initialise two vectors``    ``vector<``int``> v1, v2;` `    ``for` `(``int` `i = 0; i < n; i++) {``        ``if` `(arr[i] % k == p) {` `            ``// first vector contains indices of``            ``// required element``            ``v1.push_back(i);` `            ``// second vector contains``            ``// required elements``            ``v2.push_back(arr[i]);``        ``}``    ``}` `    ``// sorting the elements in second vector``    ``sort(v2.begin(), v2.end());` `    ``// replacing the elements whose modulo with K yields P``    ``// with the sorted elements``    ``for` `(``int` `i = 0; i < v1.size(); i++)``        ``arr[v1[i]] = v2[i];` `    ``// printing the new sorted array elements``    ``for` `(``int` `i = 0; i < n; i++)``        ``cout << arr[i] << ``" "``;``}` `// Driver code``int` `main()``{``    ``int` `arr[] = { 8, 255, 16, 2, 4, 0 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);``    ``int` `k = 2;``    ``int` `p = 0;` `    ``sortWithRemainderP(arr, n, k, p);` `    ``return` `0;``}`

## Java

 `// Java program for sorting array elements``// whose modulo with K yields P``import` `java.util.*;``class` `GFG``{` `// Function to sort elements``// whose modulo with K yields P``static` `void` `sortWithRemainderP(``int` `arr[], ``int` `n, ``int` `k, ``int` `p)``{``    ``// initialise two vectors``    ``Vector v1 = ``new` `Vector();``    ``Vector v2 = ``new` `Vector();` `    ``for` `(``int` `i = ``0``; i < n; i++)``    ``{``        ``if` `(arr[i] % k == p)``        ``{` `            ``// first vector contains indices of``            ``// required element``            ``v1.add(i);` `            ``// second vector contains``            ``// required elements``            ``v2.add(arr[i]);``        ``}``    ``}` `    ``// sorting the elements in second vector``    ``Collections.sort(v2);` `    ``// replacing the elements whose modulo with K yields P``    ``// with the sorted elements``    ``for` `(``int` `i = ``0``; i < v1.size(); i++)``        ``arr[v1.get(i)] = v2.get(i);` `    ``// printing the new sorted array elements``    ``for` `(``int` `i = ``0``; i < n; i++)``            ``System.out.print(arr[i]+``" "``);``}` `// Driver code``public` `static` `void` `main(String[] args)``{``    ``int` `arr[] = { ``8``, ``255``, ``16``, ``2``, ``4``, ``0` `};``    ``int` `n = arr.length;``    ``int` `k = ``2``;``    ``int` `p = ``0``;` `    ``sortWithRemainderP(arr, n, k, p);``    ``}``}` `// This code is contributed by 29AjayKumar`

## Python3

 `# Python 3 program for sorting array``# elements whose modulo with K yields P` `# Function to sort elements whose modulo``# with K yields P``def` `sortWithRemainderP(arr, n, k, p):``    ` `    ``# initialise two vectors``    ``v1 ``=` `[]``    ``v2 ``=` `[]` `    ``for` `i ``in` `range``(``0``, n, ``1``):``        ``if` `(arr[i] ``%` `k ``=``=` `p):``            ` `            ``# first vector contains indices``            ``# of required element``            ``v1.append(i)` `            ``# second vector contains``            ``# required elements``            ``v2.append(arr[i])` `    ``# sorting the elements in second vector``    ``v2.sort(reverse ``=` `False``)` `    ``# replacing the elements whose modulo``    ``# with K yields P with the sorted elements``    ``for` `i ``in` `range``(``0``, ``len``(v1), ``1``):``        ``arr[v1[i]] ``=` `v2[i]` `    ``# printing the new sorted array elements``    ``for` `i ``in` `range``(``0``, n, ``1``):``        ``print``(arr[i], end ``=` `" "``)` `# Driver code``if` `__name__ ``=``=` `'__main__'``:``    ``arr ``=` `[``8``, ``255``, ``16``, ``2``, ``4``, ``0``]``    ``n ``=` `len``(arr)``    ``k ``=` `2``    ``p ``=` `0` `    ``sortWithRemainderP(arr, n, k, p)``    ` `# This code is contributed by``# Sahil_Shelangia`

## C#

 `// C# program for sorting array elements``// whose modulo with K yields P``using` `System;``using` `System.Collections.Generic;` `class` `GFG``{` `// Function to sort elements``// whose modulo with K yields P``static` `void` `sortWithRemainderP(``int` `[]arr, ``int` `n,``                               ``int` `k, ``int` `p)``{``    ``// initialise two vectors``    ``List<``int``> v1 = ``new` `List<``int``>();``    ``List<``int``> v2 = ``new` `List<``int``>();` `    ``for` `(``int` `i = 0; i < n; i++)``    ``{``        ``if` `(arr[i] % k == p)``        ``{` `            ``// first vector contains indices of``            ``// required element``            ``v1.Add(i);` `            ``// second vector contains``            ``// required elements``            ``v2.Add(arr[i]);``        ``}``    ``}` `    ``// sorting the elements in second vector``    ``v2.Sort();` `    ``// replacing the elements whose modulo with``    ``// K yields P with the sorted elements``    ``for` `(``int` `i = 0; i < v1.Count; i++)``        ``arr[v1[i]] = v2[i];` `    ``// printing the new sorted array elements``    ``for` `(``int` `i = 0; i < n; i++)``        ``Console.Write(arr[i] + ``" "``);``}` `// Driver code``public` `static` `void` `Main(String[] args)``{``    ``int` `[]arr = { 8, 255, 16, 2, 4, 0 };``    ``int` `n = arr.Length;``    ``int` `k = 2;``    ``int` `p = 0;` `    ``sortWithRemainderP(arr, n, k, p);``}``}` `// This code is contributed by PrinciRaj1992`

## PHP

 ``

## Javascript

 ``

Output

`0 255 2 4 8 16 `

Time Complexity: O(nlogn)

My Personal Notes arrow_drop_up