Skip to content
Related Articles

Related Articles

Improve Article

Sort elements of array whose modulo with K yields P

  • Difficulty Level : Basic
  • Last Updated : 12 May, 2021

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 <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;
}

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

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




<?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
?>

Javascript




<script>
 
 
// Javascript 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
    var v1 = [], v2 = [];
 
    for (var i = 0; i < n; i++) {
        if (arr[i] % k == p) {
 
            // first vector contains indices of
            // required element
            v1.push(i);
 
            // second vector contains
            // required elements
            v2.push(arr[i]);
        }
    }
 
    // sorting the elements in second vector
    v2.sort((a,b)=> a-b)
 
    // replacing the elements whose modulo with K yields P
    // with the sorted elements
    for (var i = 0; i < v1.length; i++)
        arr[v1[i]] = v2[i];
 
    // printing the new sorted array elements
    for (var i = 0; i < n; i++)
        document.write( arr[i] + " ");
}
 
// Driver code
var arr = [8, 255, 16, 2, 4, 0 ];
var n = arr.length;
var k = 2;
var p = 0;
sortWithRemainderP(arr, n, k, p);
 
</script>
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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.




My Personal Notes arrow_drop_up
Recommended Articles
Page :