# Sort elements of array whose modulo with K yields P

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

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

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++ 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 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 `

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

 ` `

Output:
```0 255 2 4 8 16
```

Time Complexity : O(nlogn)

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.

Check out this Author's contributed articles.

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

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Article Tags :
Practice Tags :