Relocate Marbles - Practice Coding Problems

Relocate Marbles - Problem

Marble Relocation Challenge

Imagine you have a collection of marbles scattered across different positions on a number line. You're given a series of movement instructions that tell you to pick up all marbles from one position and move them to another position.

🎯 Your Goal: After executing all movement instructions, return a sorted list of all positions that still contain at least one marble.

Input:
• nums - Array of initial marble positions
• moveFrom - Array of source positions for each move
• moveTo - Array of destination positions for each move

Output: Sorted array of final occupied positions

Note: Multiple marbles can occupy the same position, but we only care about which positions are occupied, not how many marbles are at each position.

Input & Output

example_1.py — Basic Movement

$ Input: nums = [1,6,7,8], moveFrom = [1,7,2], moveTo = [2,9,5]

› Output: [5,6,8,9]

💡 Note: Initial: marbles at [1,6,7,8]. Move 1→2: [2,6,7,8]. Move 7→9: [2,6,8,9]. Move 2→5: [5,6,8,9].

example_2.py — Multiple Marbles Same Position

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

› Output: [2]

💡 Note: Initial: marbles at [1,1,3,3]. Move all from 1→2: [2,2,3,3]. Move all from 3→2: [2,2,2,2]. Only position 2 is occupied.

example_3.py — No Moves

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

› Output: [1,2,3]

💡 Note: No moves to execute, so marbles remain at their initial positions [1,2,3].

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ moveFrom.length, moveTo.length ≤ 10⁵
moveFrom.length == moveTo.length
1 ≤ nums[i], moveFrom[i], moveTo[i] ≤ 10⁹
Important: moveFrom[i] will always have at least one marble

Visualization

Tap to expand

Understanding the Visualization

Initial Occupancy

Rooms 1, 6, 7, and 8 have guests

Renovation Notice

Move all guests from room 1 to room 2

Another Move

Move all guests from room 7 to room 9

Final Move

Move all guests from room 2 to room 5

Final Report

Occupied rooms: 5, 6, 8, 9

Key Takeaway

🎯 Key Insight: We only need to track which positions are occupied, not how many marbles are at each position. This makes a set the perfect data structure for optimal O(n+m) performance.

Asked in

G Google 45 a Amazon 32 f Meta 28 ⊞ Microsoft 22

The optimal solution uses a hash set to track occupied positions. Instead of simulating individual marble movements, we only track which positions are occupied. For each move, we remove the source position and add the destination position to our set. This gives us O(n + m) time complexity where n is initial positions and m is number of moves.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Hash Set (Optimal)	O(n + m + k*log(k))	O(k)	Use a set to track occupied positions, updating efficiently during moves
Brute Force (Simulation with List)	O(nm + klog(k))	O(n)	Simulate each move by maintaining a list of all marble positions

One-Pass Hash Set (Optimal) — Algorithm Steps

Create a set from initial marble positions
For each move instruction (from, to):
If 'from' position exists in set, remove it
Add 'to' position to set
Convert set to sorted list and return

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Set

Create set with initial positions: {1,6,7,8}

Move 1→2

Remove 1, add 2: {2,6,7,8}

Move 7→4

Remove 7, add 4: {2,4,6,8}

Sort Result

Convert set to sorted array: [2,4,6,8]

Code -

solution.c — C

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

#define MAX_SIZE 100000

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

int* relocateMarbles(int* nums, int numsSize, int* moveFrom, int* moveTo, int moveSize, int* returnSize) {
    // Use simple array as hash set (assuming reasonable range)
    bool occupied[MAX_SIZE] = {false};
    int minPos = nums[0], maxPos = nums[0];
    
    // Mark initial positions and find range
    for (int i = 0; i < numsSize; i++) {
        occupied[nums[i]] = true;
        if (nums[i] < minPos) minPos = nums[i];
        if (nums[i] > maxPos) maxPos = nums[i];
    }
    
    // Process moves and update range
    for (int i = 0; i < moveSize; i++) {
        int fromPos = moveFrom[i];
        int toPos = moveTo[i];
        
        if (fromPos < MAX_SIZE) occupied[fromPos] = false;
        if (toPos < MAX_SIZE) occupied[toPos] = true;
        
        if (toPos < minPos) minPos = toPos;
        if (toPos > maxPos) maxPos = toPos;
    }
    
    // Collect occupied positions
    int* result = (int*)malloc(numsSize * sizeof(int));
    int count = 0;
    
    for (int i = minPos; i <= maxPos && i < MAX_SIZE; i++) {
        if (occupied[i]) {
            result[count++] = i;
        }
    }
    
    *returnSize = count;
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + m + k*log(k))

n initial positions, m moves, k unique final positions for sorting

⚡ Linearithmic

Space Complexity

O(k)

k unique positions stored in set

✓ Linear Space

42.0K Views

Medium Frequency

~15 min Avg. Time

1.9K 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

One-Pass Hash Set (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler