Moving Stones Until Consecutive - Practice Coding Problems

Moving Stones Until Consecutive - Problem

Math Brainteaser Medium

Moving Stones Until Consecutive

Imagine you have three stones placed at different positions on a number line. Your goal is to move them until they occupy three consecutive positions (like positions 5, 6, 7).

🎯 The Rules:
• You can only pick up stones from the endpoints (leftmost or rightmost stone)
• You can only place a stone in an unoccupied position between the current leftmost and rightmost stones
• The game ends when all three stones are in consecutive positions

📊 Your Task:
Given three integers a, b, and c representing the initial positions of the stones, return an array [min_moves, max_moves] where:
• min_moves is the minimum number of moves needed
• max_moves is the maximum number of moves possible

Example: If stones are at positions [1, 2, 5], you could move the stone at 5 to position 3 in just 1 move to get [1, 2, 3]. But you could also make more moves by moving strategically to maximize the total number of moves.

Input & Output

example_1.py — Basic Case

$ Input: 1 2 5

› Output: [1, 2]

💡 Note: Stones at [1,2,5]. Min: Move stone 5 to position 3 in 1 move. Max: Use both empty spaces (3,4) in 2 moves total.

example_2.py — Already Consecutive

$ Input: 4 3 2

› Output: [0, 0]

💡 Note: Stones are already at consecutive positions [2,3,4] when sorted. No moves needed.

example_3.py — Large Gaps

$ Input: 1 8 10

› Output: [2, 7]

💡 Note: Min: Need 2 moves to make consecutive. Max: Can use all 7 empty spaces (positions 2,3,4,5,6,7,9) strategically.

Visualization

Tap to expand

Understanding the Visualization

Identify the Situation

Sort the positions to see left, middle, right arrangement and measure gaps

Quick Win Check

If any two people are already next to each other, just 1 move needed

Calculate Minimum

Special cases for close positions, otherwise 2 moves in general

Calculate Maximum

Count all empty spaces that could be used strategically

Key Takeaway

🎯 Key Insight: This problem is solved through mathematical gap analysis rather than move simulation. The minimum depends on existing consecutive stones, while the maximum equals total empty spaces between the outermost stones.

Time & Space Complexity

Time Complexity

⏱️

O(1)

Just a few mathematical calculations regardless of stone positions

✓ Linear Growth

Space Complexity

O(1)

Only using a constant amount of extra space

✓ Linear Space

Constraints

1 ≤ a, b, c ≤ 100
a, b, and c have different values
The stones are on a number line with integer positions

Asked in

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

The optimal solution uses mathematical analysis instead of simulation. After sorting the positions, we analyze gaps: minimum moves depend on whether stones are already consecutive or nearly consecutive (0-2 moves), while maximum moves equal the total empty spaces between the outer stones. This gives us O(1) time complexity with just a few calculations.

Common Approaches

Approach	Time	Space	Notes
✓ Mathematical Analysis (Optimal)	O(1)	O(1)	Analyze gaps between stones mathematically without simulation

Mathematical Analysis (Optimal) — Algorithm Steps

Sort the three positions to get left, middle, right stones
For minimum moves: Check if any two stones are already consecutive or have gap of 1
If two stones are consecutive, only 1 move needed to bring third stone
If two stones have gap of 1, only 1 move needed to fill the gap
Otherwise, 2 moves needed in general case
For maximum moves: Sum up all the 'movable' spaces on both sides
Maximum is (middle - left - 1) + (right - middle - 1)

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort Positions

Arrange stones as left, middle, right

Analyze Gaps

Count empty spaces between each pair of stones

Min Moves Logic

Special cases for consecutive or near-consecutive stones

Max Moves Calculation

Sum of all available empty spaces

Code -

solution.c — C

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

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

int* numMovesStones(int a, int b, int c) {
    // Sort the positions
    int stones[3] = {a, b, c};
    qsort(stones, 3, sizeof(int), compare);
    int x = stones[0], y = stones[1], z = stones[2];
    
    // Allocate result array
    int* result = (int*)malloc(2 * sizeof(int));
    
    // Calculate minimum moves
    int minMoves;
    if (z - x == 2) {  // Already consecutive
        minMoves = 0;
    } else if (z - y == 1 || y - x == 1) {  // Two stones consecutive
        minMoves = 1;
    } else if (z - y == 2 || y - x == 2) {  // Gap of 1
        minMoves = 1;
    } else {
        minMoves = 2;
    }
    
    // Calculate maximum moves
    int maxMoves = (y - x - 1) + (z - y - 1);
    
    result[0] = minMoves;
    result[1] = maxMoves;
    return result;
}

int main() {
    int a, b, c;
    scanf("%d %d %d", &a, &b, &c);
    
    int* result = numMovesStones(a, b, c);
    printf("[%d, %d]\n", result[0], result[1]);
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Just a few mathematical calculations regardless of stone positions

✓ Linear Growth

Space Complexity

O(1)

Only using a constant amount of extra space

✓ Linear Space

Constraints

1 ≤ a, b, c ≤ 100
a, b, and c have different values
The stones are on a number line with integer positions

27.8K Views

Medium Frequency

~15 min Avg. Time

892 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Mathematical Analysis (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler