Minimum Number Game - Practice Coding Problems

Minimum Number Game - Problem

Alice and Bob are playing a competitive game with an array of numbers! 🎮

You are given a 0-indexed integer array nums of even length and there is also an empty array arr. Alice and Bob take turns in a specific pattern:

Round Rules:
- First, Alice removes the minimum element from nums
- Then, Bob removes the minimum element from the remaining nums
- Next, Bob appends his removed element to arr
- Finally, Alice appends her removed element to arr

The game continues until nums becomes empty. Your task is to return the resulting array arr after all rounds are complete.

Example: If nums = [5,4,2,3], Alice takes 2 (min), Bob takes 3 (new min), Bob adds 3 first, Alice adds 2, giving [3,2]. Next round: Alice takes 4, Bob takes 5, result: [3,2,5,4].

Input & Output

example_1.py — Python

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

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

💡 Note: Round 1: Alice takes 2 (minimum), Bob takes 3 (next minimum). Bob appends 3, Alice appends 2 → [3,2]. Round 2: Alice takes 4, Bob takes 5. Bob appends 5, Alice appends 4 → [3,2,5,4]

example_2.py — Python

$ Input: nums = [2,5]

› Output: [5,2]

💡 Note: Only one round: Alice takes 2, Bob takes 5. Bob appends first (5), then Alice (2) → [5,2]

example_3.py — Python

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

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

💡 Note: Round 1: Alice→1, Bob→2, result [2,1]. Round 2: Alice→3, Bob→4, result [2,1,4,3]. Round 3: Alice→5, Bob→6, result [2,1,4,3,6,5]. Pattern: swap each consecutive pair from sorted array.

Constraints

2 ≤ nums.length ≤ 100
nums.length is even
1 ≤ nums[i] ≤ 100

Visualization

Tap to expand

Understanding the Visualization

Sort the treasures

Arrange all treasures by value: [2,3,4,5]

First round picks

Alice gets smallest (2), Bob gets next smallest (3)

First round placement

Bob places first: [3], then Alice: [3,2]

Continue pattern

Repeat for remaining pairs: [3,2,5,4]

Key Takeaway

🎯 Key Insight: Instead of simulating the game step-by-step (O(n²)), we recognize that the result is simply the sorted array with consecutive pairs swapped, achieving O(n log n) time complexity.

Asked in

G Google 12 a Amazon 8 ⊞ Microsoft 6 f Meta 4

The optimal solution uses sorting to avoid repeated minimum searches. Since Alice and Bob always pick the two smallest available elements, we can sort the array once and then process consecutive pairs. The key insight is that Bob appends his element first, so we effectively swap each adjacent pair in the sorted array. Time complexity: O(n log n) for sorting, Space: O(1) extra.

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers (Optimal Sorting Approach)	O(n log n)	O(n)	Sort the array first, then process pairs efficiently using indices
Brute Force (Repeated Min Search)	O(n²)	O(1)	Simulate the game exactly by finding and removing minimum elements repeatedly

Two Pointers (Optimal Sorting Approach) — Algorithm Steps

Sort the input array in ascending order
Initialize result array of same length
Iterate through sorted array in steps of 2
For each pair (alice, bob), add bob first then alice to result
This effectively swaps each consecutive pair in sorted order
Return the result array

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort Array

nums = [5,4,2,3] becomes [2,3,4,5]

Process First Pair

Alice gets 2, Bob gets 3. Bob goes first: [3,2]

Process Second Pair

Alice gets 4, Bob gets 5. Bob goes first: [3,2,5,4]

Complete

Result is simply swapped pairs from sorted array

Code -

solution.c — C

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

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

int* numberGame(int* nums, int numsSize, int* returnSize) {
    // Sort to get elements in ascending order
    qsort(nums, numsSize, sizeof(int), compare);
    
    // Process pairs and swap positions
    int* arr = (int*)malloc(numsSize * sizeof(int));
    for (int i = 0; i < numsSize; i += 2) {
        int alicePick = nums[i];     // Alice picks smaller
        int bobPick = nums[i + 1];   // Bob picks next smaller
        
        // Bob appends first, then Alice
        arr[i] = bobPick;
        arr[i + 1] = alicePick;
    }
    
    *returnSize = numsSize;
    return arr;
}

int main() {
    int n;
    scanf("%d", &n);
    int* nums = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) {
        scanf("%d", &nums[i]);
    }
    
    int returnSize;
    int* result = numberGame(nums, n, &returnSize);
    
    for (int i = 0; i < returnSize; i++) {
        printf("%d%s", result[i], i < returnSize - 1 ? " " : "");
    }
    
    free(nums);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Sorting takes O(n log n) time, and the subsequent pair processing takes O(n) time, so overall O(n log n)

⚡ Linearithmic

Space Complexity

O(n)

Need O(n) space for the result array (required by problem), sorting may use O(log n) additional space

⚡ Linearithmic Space

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

Two Pointers (Optimal Sorting Approach) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler