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:
- Initialize a vector of pairs A and initialize A[i] as {arr[i], i}.
- Sort vector A[] by the first element of the pair.
- Sort the elements over the range [M, N – 1] by the second element of the pair.
- Now, iterate over the given range [M, N – 1] using the variable i and print the value of A[i].first as the resultant array element.
Below is the implementation of the above approach:
// C++ program for the above approach #include <bits/stdc++.h> using namespace std;
// Function to print the array after // removing the smallest M elements void removeSmallestM( int arr[], int N,
int M)
{ // Store pair of {element, index}
vector<pair< int , int > > A;
// Iterate over the range [0, N]
for ( int i = 0; i < N; i++) {
A.emplace_back(arr[i], i);
}
// Sort with respect to the
// first value
sort(A.begin(), A.end());
// Sort from the index M to N - 1
// using comparator for sorting
// by the second value
sort(A.begin() + M, A.end(),
[&](pair< int , int > a, pair< int , int > b) {
return a.second < b.second;
});
// Traverse from M to N - 1
for ( int i = M; i < N; i++) {
cout << A[i].first << " " ;
}
} // Driver Code 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 program for the above approach # Function to print the array after # removing the smallest M elements def removeSmallestM(arr, N, M):
# Store pair of {element, index}
A = []
# Iterate over the range [0, N]
for i in range (N):
A.append([arr[i], i])
# Sort with respect to the
# first value
A = sorted (A)
B = []
for i in range (M, N):
B.append([A[i][ 1 ], A[i][ 0 ]])
B = sorted (B)
# Traverse from M to N - 1
for i in range ( len (B)):
print (B[i][ 1 ], end = " " )
# Driver Code if __name__ = = '__main__' :
M = 5
arr = [ 2 , 81 , 75 , 98 , 72 ,
63 , 53 , 5 , 40 , 92 ]
N = len (arr)
removeSmallestM(arr, N, M)
# This code is contributed by mohit kumar 29 |
<script> // JavaScript program for the above approach // Function to print the array after // removing the smallest M elements function removeSmallestM(arr, N, M) {
// Store pair of {element, index}
let A = [];
// Iterate over the range [0, N]
for (let i = 0; i < N; i++) {
A.push([arr[i], i]);
}
// Sort with respect to the
// first value
A.sort((a, b) => a[0] - b[0]);
// Sort from the index M to N - 1
// using comparator for sorting
// by the second value
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] + " " )
}
} // Driver Code let M = 5; let arr = [2, 81, 75, 98, 72, 63, 53, 5, 40, 92];
let N = arr.length removeSmallestM(arr, N, M); </script> |
import java.util.*;
// class to represent the pair
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 {
// Function to print the array after
// removing the smallest M elements
public static void removeSmallestM( int [] arr, int N, int M) {
// Store pair of {element, index}
ArrayList<Pair> A = new ArrayList<>();
// Iterate over the range [0, N]
for ( int i = 0 ; i < N; i++) {
A.add( new Pair(arr[i], i));
}
// Sort with respect to the
// first value
Collections.sort(A, new Comparator<Pair>() {
@Override
public int compare(Pair a, Pair b) {
return a.first - b.first;
}
});
// Sort from the index M to N - 1
// using comparator for sorting
// by the second value
Collections.sort(A.subList(M, N), new Comparator<Pair>() {
@Override
public int compare(Pair a, Pair b) {
return a.second - b.second;
}
});
// Traverse from M to N - 1
for ( int i = M; i < N; i++) {
System.out.print(A.get(i).first + " " );
}
System.out.println();
}
// Driver Code
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);
}
} |
using System;
using System.Linq;
class Program {
// Function to print the array after
// removing the smallest M elements
static void RemoveSmallestM( int [] arr, int N, int M) {
// Store pair of {element, index}
var A = new int [N][];
for ( int i = 0; i < N; i++) {
A[i] = new int [] { arr[i], i };
}
// Sort with respect to the first value
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] };
}
// Sort with respect to the first value
Array.Sort(B, (a, b) => a[0].CompareTo(b[0]));
// Traverse from M to N - 1
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);
}
} |
81 75 98 72 92
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++ program for the above approach #include <bits/stdc++.h> using namespace std;
// Function to print the array after // removing the smallest M elements void removeSmallestM( int arr[], int N,
int M)
{ // Stores the copy of arr
vector< int > A(arr, arr + N);
// Sort the vector in increasing
// order
sort(A.begin(), A.end());
// Stores the smallest M elements
unordered_map< int , int > mp;
for ( int i = 0; i < M; i++) {
// Insert A[i] in the map
mp[A[i]] = 1;
}
for ( int i = 0; i < N; i++) {
// If current value is present
// in the hashmap
if (mp.find(arr[i]) == mp.end()) {
// Print the value of
// current element
cout << arr[i] << " " ;
}
}
} // Driver Code 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 program for the above approach 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;
}
// Function to print the array after
// removing the smallest M elements
static void removeSmallestM( int arr[], int N,
int M)
{
// Stores the copy of arr
int [] A = new int [N];
for ( int i = 0 ;i<N;i++)
A[i] = arr[i];
// Sort the vector in increasing
// order
Arrays.sort(A);
A = reverse(A);
// Stores the smallest M elements
Map<Integer,Integer> mp = new LinkedHashMap<Integer,Integer>();
for ( int i = 0 ; i < M; i++) {
// Insert A[i] in the map
mp.put(A[i], 1 );
}
for ( int i = 0 ; i < N; i++)
{
// If current value is present
// in the hashmap
if (mp.containsKey(arr[i]))
{
// Print the value of
// current element
System.out.print(arr[i]+ " " );
}
}
}
// Driver Code
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);
}
} // This code is contributed by Rajput-Ji |
# Python Program for the above approach # Function to print the array after # removing the smallest M elements def removeSmallestM(arr, N, M) :
# Stores the copy of arr
A = arr.copy()
# Sort the vector in increasing
# order
A.sort()
# Stores the smallest M elements
mp = {}
for i in range (M) :
# Insert A[i] in the map
mp[A[i]] = 1
for i in range (N) :
# If current value is present
# in the hashmap
if arr[i] not in mp :
# Print the value of
# current element
print (arr[i], end = " " )
# Driver Code M = 5
arr = [ 2 , 81 , 75 , 98 , 72 , 63 , 53 , 5 , 40 , 92 ]
N = len (arr)
removeSmallestM(arr, N, M) # This code is contributed by gfgking |
// C# program for the above approach using System;
using System.Linq;
using System.Collections.Generic;
class GFG {
static void removeSmallestM( int [] arr, int N, int M) {
// Stores the copy of arr
int [] A = new int [N];
for ( int i = 0; i < N ; i++){
A[i] = arr[i];
}
// Sort the vector in increasing
// order
Array.Sort(A);
// Stores the smallest M elements
Dictionary< int , int > mp = new Dictionary< int , int >();
for ( int i = 0; i < M; i++) {
// Insert A[i] in the map
mp[A[i]] = 1;
}
for ( int i = 0; i < N; i++) {
// If current value is not present
// in the hashmap
if (!mp.ContainsKey(arr[i])) {
// Print the value of
// current element
Console.Write(arr[i] + " " );
}
}
}
// Driver Code
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);
}
} |
<script> // JavaScript Program for the above approach
// Function to print the array after
// removing the smallest M elements
function removeSmallestM(arr, N, M) {
// Stores the copy of arr
let A = [...arr];
// Sort the vector in increasing
// order
A.sort( function (a, b) { return a - b; })
// Stores the smallest M elements
let mp = new Map();
for (let i = 0; i < M; i++) {
// Insert A[i] in the map
mp.set(A[i], 1);
}
for (let i = 0; i < N; i++) {
// If current value is present
// in the hashmap
if (mp.has(arr[i]) == false ) {
// Print the value of
// current element
document.write(arr[i] + " " );
}
}
}
// Driver Code
let M = 5;
let arr = [2, 81, 75, 98, 72,
63, 53, 5, 40, 92];
let N = arr.length;
removeSmallestM(arr, N, M);
// This code is contributed by Potta Lokesh
</script> |
81 75 98 72 92
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).