GFG App
Open App
Browser
Continue

# 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

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