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:



Below is the implementation of the above approach:

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program for sorting array elements
// whose modulo with K yields P
  
#include <bits/stdc++.h>
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;
}
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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<Integer> v1 = new Vector<Integer>();
    Vector<Integer> v2 = new Vector<Integer>(); 
  
    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
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

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

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

<?php
// PHP program for sorting array elements
// whose modulo with K yields P
  
// Function to sort elements
// whose modulo with K yields P
function sortWithRemainderP($arr, $n, $k, $p)
{
    // initialise two vectors
    $v1 = array();
    $v2 = array();
  
    for ($i = 0; $i < $n; $i++) 
    {
        if ($arr[$i] % $k == $p)
        {
  
            // first vector contains indices of
            // required element
            array_push($v1, $i);
  
            // second vector contains
            // required elements
            array_push($v2, $arr[$i]);
        }
    }
  
    // sorting the elements in second vector
    sort($v2);
  
    // replacing the elements whose modulo with K 
    // yields P with the sorted elements
    for ($i = 0; $i < count($v1); $i++)
        $arr[$v1[$i]] = $v2[$i];
  
    // printing the new sorted array elements
    for ($i = 0; $i < $n; $i++)
        echo $arr[$i] . " ";
}
  
// Driver code
$arr = array( 8, 255, 16, 2, 4, 0 );
$n = count($arr);
$k = 2;
$p = 0;
  
sortWithRemainderP($arr, $n, $k, $p);
  
// This code is contributed by mits
?>
chevron_right

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 :