Minimum Number of Operations to Make Array Continuous

Minimum Number of Operations to Make Array Continuous - Problem

You are given an integer array nums and need to transform it into a continuous array with the minimum number of operations. In one operation, you can replace any element with any integer of your choice.

A continuous array must satisfy two critical conditions:
1. All elements are unique (no duplicates)
2. The range equals the length: max - min = nums.length - 1

For example, [4, 2, 5, 3] is continuous because all elements are unique and 5 - 2 = 3 = 4 - 1. However, [1, 2, 3, 5, 6] is not continuous because 6 - 1 = 5 ≠ 4.

Your goal is to find the minimum number of replacements needed to make the array continuous.

Input & Output

example_1.py — Basic Continuous Array

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

› Output: 0

💡 Note: The array is already continuous. All elements are unique and the range 5-2=3 equals length-1=3. No operations needed.

example_2.py — Array with Gaps

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

› Output: 1

💡 Note: We can keep 4 elements in a continuous range. For example, keep [2,3,5,6] and change one element to make [2,3,4,5] (change 6→4) or [3,4,5,6] (change 2→4). Only 1 operation needed.

example_3.py — Array with Duplicates

$ Input: [1,10,100,1000]

› Output: 3

💡 Note: The elements are too spread out. We can keep at most 1 element and need to replace the other 3 to form a continuous array like [1,2,3,4]. So 4-1=3 operations needed.

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹

Visualization

Tap to expand

Understanding the Visualization

Survey Current Occupancy

Remove duplicate room assignments and sort: guests in rooms [2,3,4,5]

Find Best Consecutive Range

Use sliding window to find the best 4 consecutive rooms that keep most guests

Calculate Relocations

Rooms [2,3,4,5] keep all 4 guests, so 4-4=0 relocations needed

Key Takeaway

🎯 Key Insight: Use sliding window on sorted unique elements to find the maximum number of existing elements that can fit in any continuous range, minimizing the operations needed.

Asked in

G Google 25 a Amazon 18 f Meta 15 ⊞ Microsoft 12

The optimal approach uses a sliding window technique after removing duplicates and sorting. The key insight is to find the maximum number of existing unique elements that can fit in any continuous range of length n. We slide a window across sorted unique elements, maintaining the constraint that the range (rightmost - leftmost) is less than n. The answer is n minus the maximum elements we can keep.

Common Approaches

Approach	Time	Space	Notes
✓ Sorting + Binary Search	O(n log n)	O(n)	Sort unique elements and use binary search to find range endpoints
Brute Force (Try All Ranges)	O(n²)	O(n)	Try every possible continuous range and count operations needed
Two Pointers (Sliding Window)	O(n log n)	O(n)	Sort unique elements and use sliding window to find optimal range

Sorting + Binary Search — Algorithm Steps

Remove duplicates from the array and sort the unique elements
For each unique element as potential range start
Calculate the range end as start + n - 1
Use binary search to find the rightmost position <= range end
Count elements in the valid range
Track maximum elements that can be kept across all ranges
Return n minus maximum elements that can be kept

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort Unique Elements

Sorted array: [2, 3, 4, 5]

Start at 2

Range [2, 5]: binary search for elements ≤ 5

Binary Search

Find rightmost index with value ≤ 5 → index 3

Count Elements

Elements from index 0 to 3 → 4 elements

Code -

solution.c — C

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

int compare(const void* a, const void* b) {
    return (*(int*)a - *(int*)b);
}

int binarySearch(int* arr, int size, int target) {
    int left = 0, right = size - 1, result = -1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (arr[mid] <= target) {
            result = mid;
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    return result;
}

int minOperations(int* nums, int numsSize) {
    // Remove duplicates and sort
    int unique[numsSize];
    int uniqueSize = 0;
    
    for (int i = 0; i < numsSize; i++) {
        int isDup = 0;
        for (int j = 0; j < uniqueSize; j++) {
            if (unique[j] == nums[i]) {
                isDup = 1;
                break;
            }
        }
        if (!isDup) {
            unique[uniqueSize++] = nums[i];
        }
    }
    
    qsort(unique, uniqueSize, sizeof(int), compare);
    
    int maxKeep = 0;
    
    for (int i = 0; i < uniqueSize; i++) {
        int start = unique[i];
        int end = start + numsSize - 1;
        int rightIdx = binarySearch(unique, uniqueSize, end);
        
        if (rightIdx >= i) {
            int count = rightIdx - i + 1;
            if (count > maxKeep) {
                maxKeep = count;
            }
        }
    }
    
    return numsSize - maxKeep;
}

int main() {
    int nums[1000];
    int size = 0;
    char c;
    scanf(" [");
    while (scanf("%d%c", &nums[size], &c)) {
        size++;
        if (c == ']') break;
    }
    printf("%d\n", minOperations(nums, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

O(n log n) for sorting, then O(n) iterations each with O(log n) binary search

⚡ Linearithmic

Space Complexity

O(n)

Space for storing sorted unique elements

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~25 min Avg. Time

987 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

Sorting + Binary Search — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler