Remove minimum elements from the array such that 2*min becomes more than max
Last Updated :
04 Jun, 2022
Given an array of size N. The task is to remove minimum elements from the array such that twice of minimum number is greater than the maximum number in the modified array. Print the minimum number of elements removed.
Examples:
Input: arr[] = {4, 5, 100, 9, 10, 11, 12, 15, 200}
Output: 4
Remove 4 elements (4, 5, 100, 200)
so that 2*min becomes more than max.
Input: arr[] = {4, 7, 5, 6}
Output: 0
Approach:
- sort the given array
- Traverse from left to right in the array and for each element chosen (let it be x) with the index i, find the upper_bound of (2*x). let that index be j. Then, update our required answer by (n-j+i) if (n-j+i) is less than current value of our answer.
Below is the implementation of the above approach :
C++
#include <bits/stdc++.h>
using namespace std;
int Removal(vector< int > v, int n)
{
sort(v.begin(), v.end());
int ans = INT_MAX;
for (vector< int >::iterator i = v.begin(); i != v.end();
i++) {
vector< int >::iterator j = upper_bound(v.begin(),
v.end(), (2 * (*i)));
ans = min(ans, n - ( int )(j - i));
}
return ans;
}
int main()
{
vector< int > a = { 4, 5, 100, 9, 10, 11, 12, 15, 200 };
int n = a.size();
cout << Removal(a, n);
return 0;
}
|
Java
import java.util.Arrays;
class GFG
{
public static int upperBound( int [] array,
int value)
{
int low = 0 ;
int high = array.length;
while (low < high)
{
final int mid = (low + high) / 2 ;
if (value >= array[mid])
{
low = mid + 1 ;
}
else
{
high = mid;
}
}
return low;
}
public static int Removal( int [] v, int n)
{
Arrays.sort(v);
int ans = Integer.MAX_VALUE;
int k = 0 ;
for ( int i : v)
{
int j = upperBound(v, ( 2 * i));
ans = Math.min(ans, n - (j - k));
k++;
}
return ans;
}
public static void main(String[] args)
{
int [] a = { 4 , 5 , 100 , 9 , 10 ,
11 , 12 , 15 , 200 };
int n = a.length;
System.out.println(Removal(a, n));
}
}
|
Python3
from bisect import bisect_left as upper_bound
def Removal(v, n):
v = sorted (v)
ans = 10 * * 9
for i in range ( len (v)):
j = upper_bound(v, ( 2 * (a[i])))
ans = min (ans, n - (j - i - 1 ))
return ans
a = [ 4 , 5 , 100 , 9 , 10 , 11 , 12 , 15 , 200 ]
n = len (a)
print (Removal(a, n))
|
C#
using System;
class GFG
{
public static int upperBound( int [] array,
int value)
{
int low = 0;
int high = array.Length;
while (low < high)
{
int mid = (low + high) / 2;
if (value >= array[mid])
{
low = mid + 1;
}
else
{
high = mid;
}
}
return low;
}
public static int Removal( int [] v, int n)
{
Array.Sort(v);
int ans = int .MaxValue;
int k = 0;
foreach ( int i in v)
{
int j = upperBound(v, (2 * i));
ans = Math.Min(ans, n - (j - k));
k++;
}
return ans;
}
public static void Main(String[] args)
{
int [] a = { 4, 5, 100, 9, 10,
11, 12, 15, 200 };
int n = a.Length;
Console.WriteLine(Removal(a, n));
}
}
|
Javascript
<script>
function upperBound(array, value) {
var low = 0;
var high = array.length;
while (low < high) {
var mid = parseInt((low + high) / 2);
if (value >= array[mid]) {
low = mid + 1;
} else {
high = mid;
}
}
return low;
}
function Removal(v, n) {
v.sort((a, b) => a - b);
var ans = 2147483648;
var k = 0;
for (const i of v) {
var j = upperBound(v, 2 * i);
ans = Math.min(ans, n - (j - k));
k++;
}
return ans;
}
var a = [4, 5, 100, 9, 10, 11, 12, 15, 200];
var n = a.length;
document.write(Removal(a, n));
</script>
|
Output:
4
Time complexity: O(NlogN)
Auxiliary Space: O(1)
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...