Reduce Array Size to The Half - Practice Coding Problems

Reduce Array Size to The Half - Problem

Array Hash Table Greedy Sorting Heap (Priority Queue) Medium

You are given an integer array arr. Your goal is to strategically remove elements to reduce the array size by at least half, but here's the catch: when you choose to remove a number, all occurrences of that number must be removed from the array.

Your mission: Find the minimum number of distinct integers you need to remove to achieve this goal.

For example, if you have the array [3,3,3,3,5,5,5,2,2,7] with 10 elements, you need to remove at least 5 elements. The smart strategy would be to remove all 3's (removes 4 elements) and all 5's (removes 3 elements), giving you 7 total removals with just 2 distinct numbers chosen.

Think of it as: You're a data cleanup specialist trying to minimize the number of different deletion operations while maximizing impact!

Input & Output

example_1.py — Basic Case

$ Input: arr = [3,3,3,3,5,5,5,2,2,7]

› Output: 2

💡 Note: We need to remove at least 5 elements (half of 10). The optimal strategy is to remove all 3's (4 elements) and all 5's (3 elements), totaling 7 removals with just 2 distinct numbers. This is better than other combinations like removing {3,2,7} which needs 3 distinct numbers.

example_2.py — All Elements Same

$ Input: arr = [7,7,7,7,7,7]

› Output: 1

💡 Note: All elements are the same, so removing one distinct number (7) removes all 6 elements, which is definitely at least half of 6. Only 1 distinct number needed.

example_3.py — All Elements Unique

$ Input: arr = [1,9,3,2,17,8]

› Output: 3

💡 Note: All elements appear exactly once. To remove at least 3 elements (half of 6), we need to remove 3 distinct numbers. Any combination of 3 numbers works, such as {1,9,3} or {2,17,8}.

Constraints

1 ≤ arr.length ≤ 10⁵
1 ≤ arr[i] ≤ 10⁵
arr.length is always even

Visualization

Tap to expand

Understanding the Visualization

Count Cookie Types

Count how many cookies of each type: Chocolate Chip (4), Oatmeal (3), Sugar (2), Ginger (1)

Sort by Abundance

Arrange types by quantity: [4, 3, 2, 1] - most abundant first

Greedy Removal

Remove most abundant type (4 cookies), then next (3 cookies) = 7 total removed ≥ 5 needed

Count Operations

Only 2 removal operations needed (Chocolate Chip + Oatmeal types)

Key Takeaway

🎯 Key Insight: The greedy approach works because removing high-frequency elements first maximizes impact per operation, and there's never a scenario where choosing a less frequent element over a more frequent one leads to a better solution.

Asked in

a Amazon 45 f Facebook 38 G Google 32 ⊞ Microsoft 28 Apple 25

The optimal approach uses a greedy strategy with frequency counting. First, count how many times each number appears, then greedily select the most frequent numbers until at least half the array is removed. This works because removing high-frequency elements first minimizes the total number of distinct elements needed. Time complexity is O(n + k log k) where k is the number of unique elements.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Hash + Heap (Optimal)	O(n + k log k)	O(k)	Use heap to maintain top frequencies while counting, avoiding explicit sorting
Two-Pass Hash Table + Greedy	O(n + k log k)	O(k)	Count frequencies first, then greedily select most frequent elements
Brute Force (Try All Combinations)	O(n + 2^k)	O(k)	Generate all possible subsets of distinct elements and check which ones remove at least half

One-Pass Hash + Heap (Optimal) — Algorithm Steps

Count frequency of each element using hash map
Add all frequencies to a max heap
Repeatedly extract maximum frequency from heap
Add extracted frequency to running sum until sum >= array_length / 2
Return count of extractions needed

Visualization

Tap to expand

Step-by-Step Walkthrough

Count & Build Heap

Count frequencies and build max heap

Extract Maximum

Extract highest frequency from heap

Check Target

Add to running total and check if target reached

Repeat Until Done

Continue until we've removed enough elements

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

typedef struct {
    int *data;
    int size;
    int capacity;
} MaxHeap;

MaxHeap* createHeap(int capacity) {
    MaxHeap* heap = malloc(sizeof(MaxHeap));
    heap->data = malloc(capacity * sizeof(int));
    heap->size = 0;
    heap->capacity = capacity;
    return heap;
}

void heapifyDown(MaxHeap* heap, int index) {
    int largest = index;
    int left = 2 * index + 1;
    int right = 2 * index + 2;
    
    if (left < heap->size && heap->data[left] > heap->data[largest])
        largest = left;
    if (right < heap->size && heap->data[right] > heap->data[largest])
        largest = right;
        
    if (largest != index) {
        int temp = heap->data[index];
        heap->data[index] = heap->data[largest];
        heap->data[largest] = temp;
        heapifyDown(heap, largest);
    }
}

void push(MaxHeap* heap, int value) {
    heap->data[heap->size] = value;
    int index = heap->size++;
    
    while (index > 0) {
        int parent = (index - 1) / 2;
        if (heap->data[parent] >= heap->data[index]) break;
        int temp = heap->data[parent];
        heap->data[parent] = heap->data[index];
        heap->data[index] = temp;
        index = parent;
    }
}

int pop(MaxHeap* heap) {
    int result = heap->data[0];
    heap->data[0] = heap->data[--heap->size];
    heapifyDown(heap, 0);
    return result;
}

int minSetSize(int* arr, int arrSize) {
    // Count frequencies (simplified)
    int freq[1001] = {0}; // Assuming values are small
    for (int i = 0; i < arrSize; i++) {
        freq[arr[i]]++;
    }
    
    // Build max heap with frequencies
    MaxHeap* heap = createHeap(1001);
    for (int i = 0; i < 1001; i++) {
        if (freq[i] > 0) {
            push(heap, freq[i]);
        }
    }
    
    int target = arrSize / 2;
    int removed = 0;
    int count = 0;
    
    while (removed < target) {
        removed += pop(heap);
        count++;
    }
    
    free(heap->data);
    free(heap);
    return count;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + k log k)

O(n) to count frequencies, O(k) to build heap, O(k log k) worst case for extractions

⚡ Linearithmic

Space Complexity

O(k)

O(k) space for hash map and heap storing k unique element frequencies

✓ Linear Space

42.8K Views

High Frequency

~15 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

One-Pass Hash + Heap (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler