Moving Stones Until Consecutive II

Moving Stones Until Consecutive II - Problem

There are some stones in different positions on the X-axis. You are given an integer array stones where stones[i] represents the position of the i-th stone.

Call a stone an endpoint stone if it has the smallest or largest position. In one move, you pick up an endpoint stone and move it to an unoccupied position so that it is no longer an endpoint stone.

For example, if the stones are at positions [1,2,5], you cannot move the endpoint stone at position 5 to position 3 or 4 because it would still be an endpoint stone.

The game ends when you cannot make any more moves (i.e., the stones are in consecutive positions). Return an integer array answer of length 2 where:

answer[0] is the minimum number of moves you can play
answer[1] is the maximum number of moves you can play

Input & Output

Example 1 — Basic Case

$ Input: stones = [7,4,9]

› Output: [1,2]

💡 Note: We can move 4 to 8 to get [7,8,9] in 1 move (minimum). For maximum, we can move 4 to 6, then 7 to 8 to get [6,8,9] then [8,9,10], taking 2 moves total.

Example 2 — Already Consecutive

$ Input: stones = [6,5,4,3,10]

› Output: [2,3]

💡 Note: For minimum: move 3 to 7 and 10 to 8 to get [4,5,6,7,8]. For maximum: avoid the larger gap by keeping either [3,4,5,6] or [5,6,7,8,9,10] pattern.

Example 3 — Large Gaps

$ Input: stones = [1,3,8]

› Output: [1,2]

💡 Note: Minimum: move 1 to 7 to get [3,7,8], then move endpoint to make consecutive. Maximum: move 8 to 2, then 3 to get larger sequence.

Constraints

3 ≤ stones.length ≤ 10⁴
1 ≤ stones[i] ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 f Facebook 8

The key insight is using sliding window for minimum moves and gap analysis for maximum moves. The optimal approach uses mathematical analysis: minimum moves found by sliding window technique to find the best consecutive position, maximum moves calculated by choosing the strategy that avoids the larger gap. Time: O(n log n), Space: O(1).

Common Approaches

✓ Brute Force Simulation

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

Generate all possible game states by simulating every valid endpoint move until stones are consecutive. Track the minimum and maximum number of moves across all possible game paths.

Mathematical Analysis

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

Use mathematical insight: minimum moves found by sliding window technique, maximum moves calculated by choosing the strategy that avoids the larger gap between endpoint and second stone.

Sliding Window for Minimum

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

For minimum moves, use a sliding window of size n to find the position where most stones are already in place. For maximum moves, calculate based on avoiding the larger of two gaps.

Brute Force Simulation — Algorithm Steps

Step 1: Generate all possible moves from current state
Step 2: Recursively explore each move path
Step 3: Track minimum and maximum moves to reach consecutive stones

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with stones at given positions

Generate Moves

Try moving each endpoint to valid positions

Track Results

Record minimum and maximum moves found

Code -

solution.c — C

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

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 compare(const void* a, const void* b) {
    return (*(int*)a - *(int*)b);
}

int* solution(int* stones, int stonesSize, int* returnSize) {
    *returnSize = 2;
    int* result = (int*)malloc(2 * sizeof(int));
    
    int n = stonesSize;  // Original number of stones
    
    // Remove duplicates for position calculations
    qsort(stones, stonesSize, sizeof(int), compare);
    int m = 0;
    int unique[1000];  // Assuming reasonable input size
    
    for (int i = 0; i < stonesSize; i++) {
        if (i == 0 || stones[i] != stones[i-1]) {
            unique[m++] = stones[i];
        }
    }
    
    if (n <= 2) {
        result[0] = 0;
        result[1] = 0;
        return result;
    }
    
    // Check if already consecutive
    if (m == n && unique[m-1] - unique[0] == n - 1) {
        result[0] = 0;
        result[1] = 0;
        return result;
    }
    
    // Calculate minimum moves using sliding window
    int min_moves = n;
    int j = 0;
    for (int i = 0; i < m; i++) {
        // Find the rightmost stone that can be in a window of size n starting from unique[i]
        while (j < m && unique[j] - unique[i] + 1 <= n) {
            j++;
        }
        
        int stones_in_window = j - i;
        
        // Special case: if we have n-1 consecutive unique positions and the gap is at the end
        if (stones_in_window == n - 1 && unique[j-1] - unique[i] + 1 == n - 1) {
            if (min_moves > 2) {
                min_moves = 2;
            }
        } else {
            int candidate = n - stones_in_window;
            if (min_moves > candidate) {
                min_moves = candidate;
            }
        }
    }
    
    // Calculate maximum moves
    // Total positions needed: n consecutive positions
    // Current span: unique[-1] - unique[0] + 1 positions
    // Gaps to fill: positions not occupied by stones
    int total_gaps = (unique[m-1] - unique[0] + 1) - n;
    
    // End gaps (positions we can avoid by choosing different endpoints)
    int left_gap = unique[1] - unique[0] - 1;
    int right_gap = unique[m-1] - unique[m-2] - 1;
    
    // Maximum moves = total gaps - smaller end gap (we can avoid the smaller end gap)
    int min_gap = (left_gap < right_gap) ? left_gap : right_gap;
    int max_moves = total_gaps - min_gap;
    
    result[0] = min_moves;
    result[1] = max_moves;
    
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(2ⁿ)

Each stone can be moved to multiple positions, creating exponential branching

✓ Linear Growth

Space Complexity

O(2ⁿ)

Recursion stack and storage for all possible states

✓ Linear Space

18.8K Views

Medium Frequency

~35 min Avg. Time

425 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 Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler