Minimum Deletions to Make Array Beautiful

Minimum Deletions to Make Array Beautiful - Problem

Transform an Array into Beautiful Harmony!

You're given a 0-indexed integer array nums, and your mission is to make it beautiful with the minimum number of deletions possible.

An array is considered beautiful if:
• It has an even length (including 0)
• For all even indices i, we have nums[i] ≠ nums[i + 1]

In other words, every pair at positions (0,1), (2,3), (4,5), etc. must contain different values.

Key Rules:
• When you delete an element, all elements to the right shift left
• An empty array is considered beautiful
• Return the minimum number of deletions needed

Goal: Find the minimum deletions to create alternating pairs of different values!

Input & Output

example_1.py — Basic Case

$ Input: [1,1,2,3,5]

› Output: 1

💡 Note: We can delete the first 1 to get [1,2,3,5]. This array has even length (4) and forms pairs (1,2) and (3,5) where each pair has different values, making it beautiful.

example_2.py — All Same Elements

$ Input: [1,1,1,1]

› Output: 2

💡 Note: Since all elements are the same, we cannot form any valid pairs. We need to delete at least 2 elements to get an empty array (which is beautiful) or delete 2 elements to get [1,1] then delete both to get empty array.

example_3.py — Already Beautiful

$ Input: [1,2,3,4]

› Output: 0

💡 Note: The array is already beautiful: it has even length (4) and pairs (1,2) and (3,4) both have different values. No deletions needed.

Constraints

1 ≤ nums.length ≤ 10⁵
0 ≤ nums[i] ≤ 10⁵
Array elements can be any non-negative integers
Must return minimum number of deletions

Visualization

Tap to expand

Understanding the Visualization

Scan Left to Right

Start from the beginning, examining consecutive dancers

Different Colors? Pair Them!

When two dancers have different outfit colors, form a valid pair

Same Colors? Remove One

When colors match, remove the current dancer to avoid invalid pair

Handle Odd Remainder

If one dancer is left unpaired at the end, remove them too

Key Takeaway

🎯 Key Insight: Greedy pairing works optimally because removing a dancer when colors match is always the right choice - there's no benefit to keeping duplicate colors together, and forming valid pairs immediately maximizes our efficiency!

Asked in

G Google 42 a Amazon 35 f Meta 28 ⊞ Microsoft 23 Apple 18

The optimal solution uses a greedy approach in O(n) time. We iterate through the array trying to form valid pairs: when two consecutive elements are different, we keep both; when they're the same, we delete one. Finally, if the remaining array has odd length, we delete one more element to make it even. This works because local optimal choices (forming pairs greedily) lead to the global optimum.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(2^n * n)	O(n)	Generate all possible subsequences and check which ones are beautiful
Greedy One-Pass (Optimal)	O(n)	O(1)	Greedily form valid pairs from left to right in a single pass

Brute Force (Try All Combinations) — Algorithm Steps

Generate all possible subsequences using bit manipulation
For each subsequence, check if it's beautiful (even length + alternating pairs)
Track the minimum number of deletions needed
Return the minimum deletions found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Mask

Create binary mask representing which elements to keep

Build Subsequence

Extract elements based on mask bits

Check Beautiful

Validate if subsequence meets beauty criteria

Track Minimum

Update minimum deletions if valid

Code -

solution.c — C

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

bool isBeautiful(int* arr, int len) {
    if (len % 2 != 0) return false;
    
    for (int i = 0; i < len; i += 2) {
        if (i + 1 < len && arr[i] == arr[i + 1]) {
            return false;
        }
    }
    
    return true;
}

int minDeletion(int* nums, int n) {
    int minDeletions = n;
    
    // Try all possible subsequences
    for (int mask = 0; mask < (1 << n); mask++) {
        int* subsequence = (int*)malloc(n * sizeof(int));
        int subLen = 0;
        int deletions = 0;
        
        for (int i = 0; i < n; i++) {
            if (mask & (1 << i)) {
                subsequence[subLen++] = nums[i];
            } else {
                deletions++;
            }
        }
        
        if (isBeautiful(subsequence, subLen)) {
            if (deletions < minDeletions) {
                minDeletions = deletions;
            }
        }
        
        free(subsequence);
    }
    
    return minDeletions;
}

int main() {
    int nums[20], n = 0;
    char ch;
    scanf("%c", &ch); // '['
    
    while (scanf("%d", &nums[n])) {
        n++;
        scanf("%c", &ch); // ',' or ']'
        if (ch == ']') break;
    }
    
    printf("%d\n", minDeletion(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n * n)

2^n possible subsequences, each taking O(n) time to validate

⚠ Quadratic Growth

Space Complexity

O(n)

Space for storing current subsequence and recursion stack

⚡ Linearithmic Space

42.8K Views

Medium Frequency

~15 min Avg. Time

1.4K 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

Brute Force (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler