Minimum Number Game - Practice Coding Problems

Minimum Number Game - Problem

You are given a 0-indexed integer array nums of even length and there is also an empty array arr.

Alice and Bob decided to play a game where in every round Alice and Bob will do one move. The rules of the game are as follows:

Every round, first Alice will remove the minimum element from nums, and then Bob does the same.
Now, first Bob will append the removed element in the array arr, and then Alice does the same.
The game continues until nums becomes empty.

Return the resulting array arr.

Input & Output

Example 1 — Basic Case

$ Input: nums = [5,4,2,3]

› Output: [3,2,5,4]

💡 Note: Round 1: Alice picks min=2, Bob picks min=3. Add to result: [3,2]. Round 2: Alice picks min=4, Bob picks min=5. Add to result: [3,2,5,4]

Example 2 — Small Array

$ Input: nums = [2,5]

› Output: [5,2]

💡 Note: Only one round: Alice picks 2, Bob picks 5. Bob goes first in result: [5,2]

Example 3 — Already Sorted

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

› Output: [2,1,4,3]

💡 Note: Round 1: Alice picks 1, Bob picks 2 → [2,1]. Round 2: Alice picks 3, Bob picks 4 → [2,1,4,3]

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹
nums.length is even

Visualization

Tap to expand

Understanding the Visualization

Input

Array [5,4,2,3] and empty result array

Game Simulation

Players take turns picking minimums, Bob adds first

Output

Final result [3,2,5,4]

Key Takeaway

🎯 Key Insight: Sort first to avoid repeatedly searching for minimums - then process pairs in reverse order

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is that we can sort the array first instead of repeatedly finding minimums. After sorting, process elements in pairs where each pair represents one game round. For each pair [a,b], Bob's pick (b) goes first in the result, then Alice's pick (a). Best approach is sort first with Time: O(n log n), Space: O(1).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Simulation	O(n³)	O(1)	Repeatedly find and remove minimum elements while simulating the game
Sort First Approach	O(n log n)	O(1)	Sort the array first, then simulate the game by taking pairs

Brute Force Simulation — Algorithm Steps

While nums is not empty
Find minimum element (Alice's pick), remove it
Find minimum element again (Bob's pick), remove it
Add Bob's pick to result, then Alice's pick

Visualization

Tap to expand

Step-by-Step Walkthrough

Round 1

Alice finds min=1, Bob finds min=3

Add to Result

Bob's pick first: [3,1]

Continue

Repeat until array is empty

Code -

solution.c — C

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

int* solution(int* nums, int numsSize, int* returnSize) {
    int* result = (int*)malloc(numsSize * sizeof(int));
    int* temp = (int*)malloc(numsSize * sizeof(int));
    int* used = (int*)calloc(numsSize, sizeof(int));
    int resultIdx = 0;
    int remaining = numsSize;
    
    while (remaining > 0) {
        // Alice picks minimum
        int aliceMin = INT_MAX;
        int aliceIdx = -1;
        for (int i = 0; i < numsSize; i++) {
            if (!used[i] && nums[i] < aliceMin) {
                aliceMin = nums[i];
                aliceIdx = i;
            }
        }
        used[aliceIdx] = 1;
        remaining--;
        
        // Bob picks minimum
        int bobMin = INT_MAX;
        int bobIdx = -1;
        for (int i = 0; i < numsSize; i++) {
            if (!used[i] && nums[i] < bobMin) {
                bobMin = nums[i];
                bobIdx = i;
            }
        }
        used[bobIdx] = 1;
        remaining--;
        
        // Add to result: Bob first, then Alice
        result[resultIdx++] = bobMin;
        result[resultIdx++] = aliceMin;
    }
    
    *returnSize = numsSize;
    free(temp);
    free(used);
    return result;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Simple array parsing
    int nums[1000];
    int numsSize = 0;
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        nums[numsSize++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int returnSize;
    int* result = solution(nums, numsSize, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

For each of n/2 rounds, we scan the array twice to find minimums, and removing elements takes O(n) time

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables, not counting the output array

✓ Linear Space

25.0K Views

Medium Frequency

~15 min Avg. Time

890 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