Maximize Consecutive Elements in an Array After Modification

Maximize Consecutive Elements in an Array After Modification - Problem

You are given a 0-indexed array nums consisting of positive integers.

Initially, you can increase the value of any element in the array by at most 1.

After that, you need to select one or more elements from the final array such that those elements are consecutive when sorted in increasing order.

For example, the elements [3, 4, 5] are consecutive while [3, 4, 6] and [1, 1, 2, 3] are not.

Return the maximum number of elements that you can select.

Input & Output

Example 1 — Basic Consecutive Sequence

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

› Output: 3

💡 Note: We can modify the array to [2,2,3] or [3,2,3], giving us the consecutive sequence [1,2,3] which has length 3.

Example 2 — Optimal Selection

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

› Output: 2

💡 Note: We can modify to get [2,4,7], [1,5,7], or [1,4,8]. Best consecutive sequence we can form is length 2, like [4,5] from [1,5,7].

Example 3 — All Same Values

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

› Output: 4

💡 Note: We can keep all as [3,3,3,3] or modify some to [3,3,4,4], giving consecutive sequences like [3,4] but optimal is all same value.

Constraints

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

Visualization

Tap to expand

Asked in

G Google 25 f Meta 20 a Amazon 15 M Microsoft 12

The key insight is that each element can become either x or x+1, so we count frequencies of all possible values and find the longest consecutive sequence we can form. Best approach uses frequency counting with sliding window in O(n log n) time and O(n) space.

Common Approaches

✓ Memoization

⏱️ Time: N/A Space: N/A

Brute Force - Try All Modifications

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

For each element, try both original value and +1 value. Generate all 2^n possible combinations and check the longest consecutive sequence in each.

Dynamic Programming

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

Sort all possible values and use dynamic programming where dp[i] represents the maximum consecutive sequence length ending at the i-th value.

Frequency Count with Sliding Window

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

Each element can become x or x+1. Count frequencies of all possible values, then use sliding window technique to find the longest consecutive sequence we can form.

Algorithm Steps — Algorithm Steps

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 solution(int* nums, int n) {
    int max_length = 0;
    
    // Try all 2^n possible modifications
    for (int mask = 0; mask < (1 << n); mask++) {
        int* modified = (int*)malloc(n * sizeof(int));
        
        // Apply modifications based on mask
        for (int i = 0; i < n; i++) {
            if (mask & (1 << i)) {
                modified[i] = nums[i] + 1;  // Add 1
            } else {
                modified[i] = nums[i];      // Keep original
            }
        }
        
        // Sort the modified array
        qsort(modified, n, sizeof(int), compare);
        
        // Find longest consecutive sequence
        int current_length = 1;
        int best_length = 1;
        
        for (int i = 1; i < n; i++) {
            if (modified[i] == modified[i-1] + 1) {
                current_length++;
                if (current_length > best_length) {
                    best_length = current_length;
                }
            } else if (modified[i] != modified[i-1]) {  // Skip duplicates
                current_length = 1;
            }
        }
        
        if (best_length > max_length) {
            max_length = best_length;
        }
        
        free(modified);
    }
    
    return max_length;
}

// Parse array in format [1,2,3]
int* parseArray(char* str, int* size) {
    *size = 0;
    
    // Count numbers by counting commas + 1
    for (int i = 0; str[i]; i++) {
        if (str[i] == ',') (*size)++;
    }
    if (strchr(str, '[') != NULL) (*size)++;  // At least one number if brackets exist
    
    int* result = (int*)malloc(*size * sizeof(int));
    
    // Find start of numbers
    char* token = strchr(str, '[');
    if (!token) return result;
    token++;
    
    int idx = 0;
    while (*token && *token != ']' && idx < *size) {
        // Skip whitespace
        while (*token == ' ') token++;
        
        if (*token >= '0' && *token <= '9') {
            result[idx++] = atoi(token);
            
            // Skip to next comma or end
            while (*token && *token != ',' && *token != ']') token++;
            if (*token == ',') token++;
        } else {
            token++;
        }
    }
    
    *size = idx;
    return result;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int n;
    int* nums = parseArray(line, &n);
    
    int result = solution(nums, n);
    printf("%d\n", result);
    
    free(nums);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚡ Linearithmic

Space Complexity

⚡ Linearithmic Space

23.0K Views

Medium Frequency

~25 min Avg. Time

850 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