Moving Stones Until Consecutive II - Practice Coding Problems

Moving Stones Until Consecutive II - Problem

Imagine you have stones scattered along a number line. Your goal is to move them until they form consecutive positions (like 5, 6, 7).

Here's the catch: You can only move endpoint stones - the leftmost or rightmost stones in your collection. When you move a stone, it must land in an unoccupied position and no longer be an endpoint.

For example, with stones at [1, 2, 5], you cannot move the stone at position 5 anywhere because it would still remain the rightmost stone!

The puzzle ends when all stones are in consecutive positions. Your task is to find both the minimum and maximum number of moves possible.

Input: An integer array stones representing positions on the X-axis

Output: An array [min_moves, max_moves]

Input & Output

example_1.py — 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 6 to 7 for [7,8,9] (2 moves total).

example_2.py — Larger Gap

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

› Output: [2,3]

💡 Note: We can move 3 to 8, then 10 to 7 to get [4,5,6,7,8]. The minimum is 2 moves, maximum is 3 moves by creating larger gaps first.

example_3.py — Already Consecutive

$ Input: stones = [1,2,3,4,5]

› Output: [0,0]

💡 Note: The stones are already in consecutive positions, so no moves are needed for both minimum and maximum.

Constraints

3 ≤ stones.length ≤ 10⁴
1 ≤ stones[i] ≤ 10⁹
All values in stones are unique
At least 3 stones are required for the game to be interesting

Visualization

Tap to expand

Understanding the Visualization

Sort the Positions

First, arrange stones by position to see the current layout clearly

Find Best Window

Use sliding window to find where n consecutive positions would capture the most existing stones

Calculate Minimum

Minimum moves = n - (stones already in best window)

Calculate Maximum

For maximum, choose the endpoint move that leaves the largest gap

Key Takeaway

🎯 Key Insight: Separate minimum and maximum strategies - sliding window finds efficient packing, while greedy maximizes gaps before convergence.

Asked in

G Google 15 f Meta 12 Apple 8 a Amazon 6

The optimal approach uses sliding window technique for minimum moves and greedy strategy for maximum moves. Key insight: minimum moves find the best consecutive window, while maximum moves create the largest possible gaps before converging.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Arrangements)	O(n! × n)	O(n)	Try all possible sequences of moves to find minimum and maximum
Two Pointers + Sliding Window	O(n²)	O(1)	Use sliding window for minimum moves and greedy strategy for maximum moves

Brute Force (Try All Arrangements) — Algorithm Steps

Sort the stones array to identify endpoints easily
Use recursion to try moving left endpoint to all valid positions
Use recursion to try moving right endpoint to all valid positions
Track the number of moves for each complete solution
Return the minimum and maximum moves found

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with sorted stones array

Branch on Moves

For each endpoint, try all valid positions

Recurse

Continue exploring from each new state

Track Solutions

Record min/max when consecutive arrangement found

Code -

solution.c — C

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

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

int isConsecutive(int* arr, int size) {
    for (int i = 1; i < size; i++) {
        if (arr[i] - arr[i-1] != 1) return 0;
    }
    return 1;
}

void solve(int* stones, int n, int moves, int* minMoves, int* maxMoves) {
    if (isConsecutive(stones, n)) {
        if (moves < *minMoves) *minMoves = moves;
        if (moves > *maxMoves) *maxMoves = moves;
        return;
    }
    
    // Try moving leftmost stone
    for (int pos = stones[0] - n; pos < stones[1]; pos++) {
        int valid = 1;
        for (int i = 0; i < n; i++) {
            if (stones[i] == pos) {
                valid = 0;
                break;
            }
        }
        
        if (valid) {
            int* newStones = malloc(n * sizeof(int));
            newStones[0] = pos;
            for (int i = 1; i < n; i++) {
                newStones[i] = stones[i];
            }
            qsort(newStones, n, sizeof(int), compare);
            
            if (pos < newStones[n-1]) {
                solve(newStones, n, moves + 1, minMoves, maxMoves);
            }
            free(newStones);
        }
    }
}

int* numMovesStonesII(int* stones, int stonesSize, int* returnSize) {
    *returnSize = 2;
    int* result = malloc(2 * sizeof(int));
    
    qsort(stones, stonesSize, sizeof(int), compare);
    
    if (isConsecutive(stones, stonesSize)) {
        result[0] = 0;
        result[1] = 0;
        return result;
    }
    
    int minMoves = INT_MAX;
    int maxMoves = 0;
    
    solve(stones, stonesSize, 0, &minMoves, &maxMoves);
    
    result[0] = minMoves;
    result[1] = maxMoves;
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × n)

Each move has up to n choices, and we might need n moves, leading to factorial complexity

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth proportional to number of moves needed

⚡ Linearithmic Space

31.2K Views

Medium Frequency

~25 min Avg. Time

847 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 Arrangements) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler