Remove minimum elements from array so that max <= 2 * min
Last Updated :
11 Jul, 2025
Given an array arr, the task is to remove minimum number of elements such that after their removal, max(arr) <= 2 * min(arr).
Examples:
Input: arr[] = {4, 5, 3, 8, 3}
Output: 1 Remove 8 from the array.
Input: arr[] = {1, 2, 3, 4}
Output: 1 Remove 1 from the array.
Approach: Let us fix each value as the minimum value say x and find number of terms that are in range [x, 2*x]. This can be done using prefix-sums, we can use map (implements self balancing BST) instead of array as the values can be large. The remaining terms which are not in range [x, 2*x] will have to be removed. So, across all values of x, we choose the one which maximises the number of terms in range [x, 2*x].
Below is the implementation of the above approach:
C++
// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
// Function to return the minimum removals from
// arr such that max(arr) <= 2 * min(arr)
int minimumRemovals(int n, int a[])
{
// Count occurrence of each element
map<int, int> ct;
for (int i = 0; i < n; i++)
ct[a[i]]++;
// Take prefix sum
int sm = 0;
for (auto mn : ct) {
sm += mn.second;
ct[mn.first] = sm;
}
int mx = 0, prev = 0;
for (auto mn : ct) {
// Chosen minimum
int x = mn.first;
int y = 2 * x;
auto itr = ct.upper_bound(y);
itr--;
// Number of elements that are in
// range [x, 2x]
int cr = (itr->second) - prev;
mx = max(mx, cr);
prev = mn.second;
}
// Minimum elements to be removed
return n - mx;
}
// Driver Program to test above function
int main()
{
int arr[] = { 4, 5, 3, 8, 3 };
int n = sizeof(arr) / sizeof(arr[0]);
cout << minimumRemovals(n, arr);
return 0;
}
// Java implementation of the approach
import java.util.*;
public class Main {
// Function to return the minimum removals from
// arr such that max(arr) <= 2 * min(arr)
public static int minimumRemovals(int n, int[] a) {
// Count occurrence of each element
Map<Integer, Integer> ct = new HashMap<>();
for (int i = 0; i < n; i++) {
ct.put(a[i], ct.getOrDefault(a[i], 0) + 1);
}
// Take prefix sum
int sm = 0;
for (int mn : ct.keySet()) {
sm += ct.get(mn);
ct.put(mn, sm);
}
int mx = 0, prev = 0;
for (int mn : ct.keySet()) {
// Chosen minimum
int x = mn;
int y = 2 * x;
List<Integer> keysList = new ArrayList<>(ct.keySet());
int index = Collections.binarySearch(keysList, y);
int pos = index >= 0 ? index : -(index + 1) - 1;
Integer itr = pos >= 0 ? ct.get(keysList.get(pos)) : null;
// Number of elements that are in
// range [x, 2x]
int cr = (itr != null ? itr : 0) - prev;
mx = Math.max(mx, cr);
prev = ct.get(mn);
}
// Minimum elements to be removed
return n - mx;
}
// Driver Program to test above function
public static void main(String[] args) {
int[] arr = { 4, 5, 3, 8, 3 };
int n = arr.length;
System.out.println(minimumRemovals(n, arr));
}
}
// This code is contributed by codebraxnzt
# Python3 implementation of the approach
from bisect import bisect_left as upper_bound
# Function to return the minimum removals from
# arr such that max(arr) <= 2 * min(arr)
def minimumRemovals(n, a):
# Count occurrence of each element
ct = dict()
for i in a:
ct[i] = ct.get(i, 0) + 1
# Take prefix sum
sm = 0
for mn in ct:
sm += ct[mn]
ct[mn] = sm
mx = 0
prev = 0;
for mn in ct:
# Chosen minimum
x = mn
y = 2 * x
itr = upper_bound(list(ct), y)
# Number of elements that are in
# range [x, 2x]
cr = ct[itr] - prev
mx = max(mx, cr)
prev = ct[mn]
# Minimum elements to be removed
return n - mx
# Driver Code
arr = [4, 5, 3, 8, 3]
n = len(arr)
print(minimumRemovals(n, arr))
# This code is contributed by Mohit Kumar
// C# program for the above approach
using System;
using System.Collections.Generic;
public class MainClass
{
// Function to return the minimum removals from
// arr such that max(arr) <= 2 * min(arr)
public static int minimumRemovals(int n, int[] a)
{
// Count occurrence of each element
Dictionary<int, int> ct = new Dictionary<int, int>();
for (int i = 0; i < n; i++)
{
if (ct.ContainsKey(a[i]))
{
ct[a[i]]++;
}
else
{
ct[a[i]] = 1;
}
}
// Take prefix sum
int sm = 0;
List<int> keysList = new List<int>(ct.Keys);
keysList.Sort();
foreach (int mn in keysList)
{
sm += ct[mn];
ct[mn] = sm;
}
int mx = 0, prev = 0;
foreach (int mn in keysList)
{
// Chosen minimum
int x = mn;
int y = 2 * x;
int index = keysList.BinarySearch(y);
int pos = index >= 0 ? index : -(index + 1) - 1;
int itr = pos >= 0 ? ct[keysList[pos]] : 0;
// Number of elements that are in
// range [x, 2x]
int cr = itr - prev;
mx = Math.Max(mx, cr);
prev = ct[mn];
}
// Minimum elements to be removed
return n - mx;
}
// Driver Program to test above function
public static void Main()
{
int[] arr = { 4, 5, 3, 8, 3 };
int n = arr.Length;
Console.WriteLine(minimumRemovals(n, arr));
}
}
// This code is contributed by Prince Kumar
// JavaScript implementation of the approach
// Function to return the minimum removals from arr such that max(arr) <= 2 * min(arr)
function minimumRemovals(n, a){
// Import upper_bound from bisect
const upper_bound = (arr, x) => {
let low = 0, high = arr.length;
while (low < high) {
const mid = (low + high) >>> 1;
if (x >= arr[mid]) {
low = mid + 1;
} else {
high = mid;
}
}
return low;
}
// Count occurrence of each element
let ct = new Map();
for (let i of a){
ct.set(i, (ct.get(i) || 0) + 1);
}
// Take prefix sum
let sm = 0;
for (let mn of ct.keys()){
sm += ct.get(mn);
ct.set(mn, sm);
}
let mx = 0;
let prev = 0;
for (let mn of ct.keys()){
// Chosen minimum
let x = mn;
let y = 2 * x;
let itr = upper_bound(Array.from(ct.keys()), y);
// Number of elements that are in range [x, 2x]
let cr = ct.get([...ct.keys()][itr-1]) - ct.get(mn) + prev;
mx = Math.max(mx, cr);
prev = ct.get(mn) - (ct.get(mn - 1) || 0);
}
// Minimum elements to be removed
return n - mx;
}
// Driver Code
let arr = [4, 5, 3, 8, 3];
let n = arr.length;
console.log(minimumRemovals(n, arr));
// This code is contributed by princekumaras
Similar Reads
Remove minimum elements from the array such that 2*min becomes more than max Given an unsorted array, arr[]. The task is to find the minimum number of removals required such that twice the minimum element in the array is greater than or equal to the maximum in the array.Examples: Input: arr[] = [4, 5, 100, 9, 10, 11, 12, 15, 200]Output: 4Explanation: In the given array 4 ele
7 min read
Remove exactly one element from the array such that max - min is minimum Given an array consisting of N positive integer numbers. The task is to remove exactly one element from this array to minimize max(a) - min(a) and print the minimum possible (max(a) - min(a)). Note: max(a) means largest number in array a and min(a) means smallest number in array a . There are at lea
8 min read
Minimum removals from array to make max - min <= K Given N integers and K, find the minimum number of elements that should be removed, such that Amax-Amin<=K. After the removal of elements, Amax and Amin is considered among the remaining elements. Examples: Input : a[] = {1, 3, 4, 9, 10, 11, 12, 17, 20}, k = 4 Output : 5 Explanation: Remove 1, 3,
15+ min read
Remove minimum elements from either side such that 2*min becomes more than max Given an unsorted array, trim the array such that twice of minimum is greater than maximum in the trimmed array. Elements should be removed either end of the array.Number of removals should be minimum. Examples: arr[] = {4, 5, 100, 9, 10, 11, 12, 15, 200} Output: 4 We need to remove 4 elements (4, 5
15+ min read
Minimum elements to be removed from the ends to make the array sorted Given an array arr[] of length N, the task is to remove the minimum number of elements from the ends of the array to make the array non-decreasing. Elements can only be removed from the left or the right end. Examples: Input: arr[] = {1, 2, 4, 1, 5} Output: 2 We can't make the array sorted after one
9 min read
Minimum elements to be removed from the ends to make the array sorted Given an array arr[] of length N, the task is to remove the minimum number of elements from the ends of the array to make the array non-decreasing. Elements can only be removed from the left or the right end. Examples: Input: arr[] = {1, 2, 4, 1, 5} Output: 2 We can't make the array sorted after one
9 min read