Min Max Game

Min Max Game - Problem

Array Simulation Easy

You are given a 0-indexed integer array nums whose length is a power of 2.

Apply the following algorithm on nums:

Let n be the length of nums. If n == 1, end the process. Otherwise, create a new 0-indexed integer array newNums of length n / 2.
For every even index i where 0 <= i < n / 2, assign the value of newNums[i] as min(nums[2 * i], nums[2 * i + 1]).
For every odd index i where 0 <= i < n / 2, assign the value of newNums[i] as max(nums[2 * i], nums[2 * i + 1]).
Replace the array nums with newNums.
Repeat the entire process starting from step 1.

Return the last number that remains in nums after applying the algorithm.

Input & Output

Example 1 — Basic Case

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

› Output: 1

💡 Note: Round 1: [min(1,3), max(5,2), min(4,8), max(2,2)] = [1,5,4,2]. Round 2: [min(1,5), max(4,2)] = [1,4]. Round 3: min(1,4) = 1

Example 2 — Smaller Array

$ Input: nums = [3]

› Output: 3

💡 Note: Array has only one element, so return it directly

Example 3 — Two Elements

$ Input: nums = [9,3]

› Output: 3

💡 Note: Even index 0: min(9,3) = 3

Constraints

1 ≤ nums.length ≤ 1024
nums.length is a power of 2
1 ≤ nums[i] ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The Min-Max Game requires simulating the tournament-style elimination process. Each round, we pair adjacent elements and apply min for even indices, max for odd indices. The key insight is that we can either create new arrays each round or modify in-place. Best approach is in-place simulation with Time: O(n), Space: O(1).

Common Approaches

✓ In-Place Simulation

⏱️ Time: O(n) Space: O(1)

Instead of creating new arrays, modify the original array in-place and track the current size.

Simulation

⏱️ Time: O(n) Space: O(n)

Follow the algorithm exactly - create new arrays by pairing adjacent elements and applying min/max based on position parity.

In-Place Simulation — Algorithm Steps

Use a size variable to track active elements
Modify array in-place each round
Apply min/max rules to pairs
Reduce active size by half each round

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Original array with size tracker

In-Place Updates

Overwrite first half with min/max results

Size Reduction

Reduce active size and repeat

Code -

solution.c — C

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

int solution(int* nums, int size) {
    while (size > 1) {
        int newSize = size / 2;
        
        for (int i = 0; i < newSize; i++) {
            if (i % 2 == 0) {  // even index
                nums[i] = (nums[2 * i] < nums[2 * i + 1]) ? nums[2 * i] : nums[2 * i + 1];
            } else {  // odd index
                nums[i] = (nums[2 * i] > nums[2 * i + 1]) ? nums[2 * i] : nums[2 * i + 1];
            }
        }
        
        size = newSize;
    }
    
    return nums[0];
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Simple JSON array parsing
    int nums[1000];
    int size = 0;
    
    char* ptr = strchr(line, '[');
    if (ptr) {
        ptr++;
        char* token = strtok(ptr, ",]\n");
        while (token && size < 1000) {
            nums[size++] = atoi(token);
            token = strtok(NULL, ",]\n");
        }
    }
    
    int result = solution(nums, size);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Same as simulation approach - we process n + n/2 + n/4 + ... = O(n) elements total

✓ Linear Growth

Space Complexity

O(1)

Only uses the input array and a few variables, no extra arrays created

⚡ Linearithmic Space

25.0K Views

Medium Frequency

~15 min Avg. Time

850 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

In-Place Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler