Modify array by removing M smallest elements maintaining the order of remaining elements
Last Updated :
08 Mar, 2023
Given a positive integer M and an array consisting of N distinct positive integers, the task is to remove the first M smallest elements from the array such that the relative order of the remaining element doesn’t alter.
Examples:
Input: M = 5, arr[] = {2, 81, 75, 98, 72, 63, 53, 5, 40, 92}
Output: 81 75 98 72 92
Explanation:
The first M(= 5) smallest element are {2, 5, 40, 53, 63}. After removing these elements the modified array is {81, 75, 98, 72, 92}.
Input: M = 1, arr[] = {8, 3, 6, 10, 5}
Output: 8 6 10 5
Sorting-Based Approach: The given problem can be solved by pairing each array element with its index and then sort the array of pairs. Follow the steps below to solve the problem:
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
void removeSmallestM( int arr[], int N,
int M)
{
vector<pair< int , int > > A;
for ( int i = 0; i < N; i++) {
A.emplace_back(arr[i], i);
}
sort(A.begin(), A.end());
sort(A.begin() + M, A.end(),
[&](pair< int , int > a, pair< int , int > b) {
return a.second < b.second;
});
for ( int i = M; i < N; i++) {
cout << A[i].first << " " ;
}
}
int main()
{
int M = 5;
int arr[] = { 2, 81, 75, 98, 72,
63, 53, 5, 40, 92 };
int N = sizeof (arr) / sizeof (arr[0]);
removeSmallestM(arr, N, M);
return 0;
}
|
Python3
def removeSmallestM(arr, N, M):
A = []
for i in range (N):
A.append([arr[i], i])
A = sorted (A)
B = []
for i in range (M, N):
B.append([A[i][ 1 ], A[i][ 0 ]])
B = sorted (B)
for i in range ( len (B)):
print (B[i][ 1 ], end = " " )
if __name__ = = '__main__' :
M = 5
arr = [ 2 , 81 , 75 , 98 , 72 ,
63 , 53 , 5 , 40 , 92 ]
N = len (arr)
removeSmallestM(arr, N, M)
|
Javascript
<script>
function removeSmallestM(arr, N, M) {
let A = [];
for (let i = 0; i < N; i++) {
A.push([arr[i], i]);
}
A.sort((a, b) => a[0] - b[0]);
let B = [];
for (let i = M; i < N; i++) {
B.push([A[i][1], A[i][0]])
}
B.sort((a, b) => a[0] - b[0])
for (let i = 0; i < B.length; i++) {
document.write(B[i][1] + " " )
}
}
let M = 5;
let arr = [2, 81, 75, 98, 72,
63, 53, 5, 40, 92];
let N = arr.length
removeSmallestM(arr, N, M);
</script>
|
Java
import java.util.*;
class Pair {
public int first;
public int second;
public Pair( int first, int second) {
this .first = first;
this .second = second;
}
public int getKey() {
return first;
}
public int getVal() {
return second;
}
}
class Main {
public static void removeSmallestM( int [] arr, int N, int M) {
ArrayList<Pair> A = new ArrayList<>();
for ( int i = 0 ; i < N; i++) {
A.add( new Pair(arr[i], i));
}
Collections.sort(A, new Comparator<Pair>() {
@Override
public int compare(Pair a, Pair b) {
return a.first - b.first;
}
});
Collections.sort(A.subList(M, N), new Comparator<Pair>() {
@Override
public int compare(Pair a, Pair b) {
return a.second - b.second;
}
});
for ( int i = M; i < N; i++) {
System.out.print(A.get(i).first + " " );
}
System.out.println();
}
public static void main(String[] args) {
int M = 5 ;
int arr[] = { 2 , 81 , 75 , 98 , 72 ,
63 , 53 , 5 , 40 , 92 };
int N = arr.length;
removeSmallestM(arr, N, M);
}
}
|
C#
using System;
using System.Linq;
class Program {
static void RemoveSmallestM( int [] arr, int N, int M) {
var A = new int [N][];
for ( int i = 0; i < N; i++) {
A[i] = new int [] { arr[i], i };
}
Array.Sort(A, (a, b) => a[0].CompareTo(b[0]));
var B = new int [N - M][];
for ( int i = M; i < N; i++) {
B[i - M] = new int [] { A[i][1], A[i][0] };
}
Array.Sort(B, (a, b) => a[0].CompareTo(b[0]));
for ( int i = 0; i < B.Length; i++) {
Console.Write($ "{B[i][1]} " );
}
}
static void Main() {
int M = 5;
int [] arr = { 2, 81, 75, 98, 72, 63, 53, 5, 40, 92 };
int N = arr.Length;
RemoveSmallestM(arr, N, M);
}
}
|
Time Complexity: O(N*log N)
Auxiliary Space: O(N)
HashMap-Based Approach: The given problem can also be solved using a HashMap to store the smallest M elements of the array. Follow the steps below to solve the problem:
- Initialize an auxiliary vector, say A, and store all the array element arr[] in it.
- Sort the vector A and initialize a HashMap, say mp.
- Iterate over the range [0, M – 1] using the variable i, and insert A[i] in the HashMap.
- Iterate over the range [0, N – 1] using the variable i, and if the value of arr[i] is not present in the HashMap then print the value of arr[i] as the resultant array.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
void removeSmallestM( int arr[], int N,
int M)
{
vector< int > A(arr, arr + N);
sort(A.begin(), A.end());
unordered_map< int , int > mp;
for ( int i = 0; i < M; i++) {
mp[A[i]] = 1;
}
for ( int i = 0; i < N; i++) {
if (mp.find(arr[i]) == mp.end()) {
cout << arr[i] << " " ;
}
}
}
int main()
{
int M = 5;
int arr[] = { 2, 81, 75, 98, 72,
63, 53, 5, 40, 92 };
int N = sizeof (arr) / sizeof (arr[0]);
removeSmallestM(arr, N, M);
return 0;
}
|
Java
import java.util.*;
class GFG{
static int [] reverse( int a[]) {
int i, n = a.length, t;
for (i = 0 ; i < n / 2 ; i++) {
t = a[i];
a[i] = a[n - i - 1 ];
a[n - i - 1 ] = t;
}
return a;
}
static void removeSmallestM( int arr[], int N,
int M)
{
int [] A = new int [N];
for ( int i = 0 ;i<N;i++)
A[i] = arr[i];
Arrays.sort(A);
A = reverse(A);
Map<Integer,Integer> mp = new LinkedHashMap<Integer,Integer>();
for ( int i = 0 ; i < M; i++) {
mp.put(A[i], 1 );
}
for ( int i = 0 ; i < N; i++)
{
if (mp.containsKey(arr[i]))
{
System.out.print(arr[i]+ " " );
}
}
}
public static void main(String[] args)
{
int M = 5 ;
int arr[] = { 2 , 81 , 75 , 98 , 72 ,
63 , 53 , 5 , 40 , 92 };
int N = arr.length;
removeSmallestM(arr, N, M);
}
}
|
Python3
def removeSmallestM(arr, N, M) :
A = arr.copy()
A.sort()
mp = {}
for i in range (M) :
mp[A[i]] = 1
for i in range (N) :
if arr[i] not in mp :
print (arr[i], end = " " )
M = 5
arr = [ 2 , 81 , 75 , 98 , 72 , 63 , 53 , 5 , 40 , 92 ]
N = len (arr)
removeSmallestM(arr, N, M)
|
C#
using System;
using System.Linq;
using System.Collections.Generic;
class GFG {
static void removeSmallestM( int [] arr, int N, int M) {
int [] A = new int [N];
for ( int i = 0; i < N ; i++){
A[i] = arr[i];
}
Array.Sort(A);
Dictionary< int , int > mp = new Dictionary< int , int >();
for ( int i = 0; i < M; i++) {
mp[A[i]] = 1;
}
for ( int i = 0; i < N; i++) {
if (!mp.ContainsKey(arr[i])) {
Console.Write(arr[i] + " " );
}
}
}
public static void Main() {
int M = 5;
int [] arr = { 2, 81, 75, 98, 72, 63, 53, 5, 40, 92 };
int N = arr.Length;
removeSmallestM(arr, N, M);
}
}
|
Javascript
<script>
function removeSmallestM(arr, N, M) {
let A = [...arr];
A.sort( function (a, b) { return a - b; })
let mp = new Map();
for (let i = 0; i < M; i++) {
mp.set(A[i], 1);
}
for (let i = 0; i < N; i++) {
if (mp.has(arr[i]) == false ) {
document.write(arr[i] + " " );
}
}
}
let M = 5;
let arr = [2, 81, 75, 98, 72,
63, 53, 5, 40, 92];
let N = arr.length;
removeSmallestM(arr, N, M);
</script>
|
Time Complexity: O(N*log N), as we are sorting the array first so that required N*logN time
Auxiliary Space: O(M), as in solution we are using hashmap(unordered map) to store the first M element from the sorted array which means we store only M element in the hashmap(unordered map) so space complexity will be O(M).
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...