Minimum Deletions to Make Array Beautiful

Minimum Deletions to Make Array Beautiful - Problem

You are given a 0-indexed integer array nums. The array nums is beautiful if:

nums.length is even.
nums[i] != nums[i + 1] for all i % 2 == 0.

Note that an empty array is considered beautiful.

You can delete any number of elements from nums. When you delete an element, all the elements to the right of the deleted element will be shifted one unit to the left to fill the gap created and all the elements to the left of the deleted element will remain unchanged.

Return the minimum number of elements to delete from nums to make it beautiful.

Input & Output

Example 1 — Basic Case

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

› Output: 1

💡 Note: Delete one element to get [1,2,3] which is not beautiful (odd length), or [1,2] which is beautiful. Minimum deletions: 1 (delete either the second 1 or the last 5).

Example 2 — All Same Elements

$ Input: nums = [1,1,1,1]

› Output: 2

💡 Note: All pairs would be identical. Delete 2 elements to get [1,1] then delete both to get [] (empty array is beautiful), or keep alternating elements. Minimum: 2 deletions.

Example 3 — Already Beautiful

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

› Output: 0

💡 Note: Array has even length and nums[0] ≠ nums[1], nums[2] ≠ nums[3]. Already beautiful, no deletions needed.

Constraints

0 ≤ nums.length ≤ 10⁵
0 ≤ nums[i] ≤ 10⁵

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 a Amazon 8

The key insight is to greedily form pairs from left to right. When two consecutive elements are the same, we must delete one. The greedy approach achieves optimal solution in O(n) time and O(1) space.

Common Approaches

✓ Brute Force - Try All Combinations

⏱️ Time: O(2ⁿ) Space: O(n)

Generate all possible subsequences of the array, check which ones are beautiful, and return the one requiring minimum deletions.

Greedy Approach

⏱️ Time: O(n) Space: O(1)

Iterate through the array and greedily form pairs. When we encounter an element that would form a valid pair with the previous unpaired element, we keep both. Otherwise, we delete the current element.

Stack-Based Approach

⏱️ Time: O(n) Space: O(n)

Iterate through the array and use a stack to keep track of elements. When we can form a valid pair (top of stack is different from current element), we pop the stack. Otherwise, we push the current element.

Brute Force - Try All Combinations — Algorithm Steps

Generate all possible subsequences
Check if each subsequence is beautiful
Find the longest beautiful subsequence
Return original length minus longest beautiful length

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Subsequences

Create all 2^n possible subsequences using bitmasks

Check Beautiful

For each subsequence, verify if it's beautiful (even length, no adjacent pairs equal)

Find Minimum

Track the subsequence requiring minimum deletions

Code -

solution.c — C

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

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

int solution(int* nums, int n) {
    int minDeletions = n;
    
    // Try all possible bitmasks (2^n combinations)
    for (int mask = 0; mask < (1 << n); mask++) {
        int subsequence[1000];
        int subLen = 0;
        
        for (int i = 0; i < n; i++) {
            if (mask & (1 << i)) {
                subsequence[subLen++] = nums[i];
            }
        }
        
        // Check if this subsequence is beautiful
        if (isBeautiful(subsequence, subLen)) {
            int deletions = n - subLen;
            if (deletions < minDeletions) {
                minDeletions = deletions;
            }
        }
    }
    
    return minDeletions;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Simple array parsing
    int nums[1000];
    int n = 0;
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        if (strlen(token) > 0 && token[0] != ' ' && token[0] != '\n') {
            nums[n++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    
    int result = solution(nums, n);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2ⁿ)

We generate 2^n possible subsequences and check each one

✓ Linear Growth

Space Complexity

O(n)

Space for recursion stack and storing current subsequence

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~15 min Avg. Time

890 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