Min Max Game - Practice Coding Problems

Min Max Game - Problem

Array Simulation Easy

Imagine you're running a tournament elimination system where competitors face off in pairs, but with a twist! In each round, some pairs compete for the minimum score (even positions) while others compete for the maximum score (odd positions).

You are given a 0-indexed integer array nums whose length is a power of 2. Apply this special tournament algorithm:

If only 1 number remains, that's your winner!
Otherwise, create a new array with half the length
For even indices i: take the min(nums[2*i], nums[2*i+1])
For odd indices i: take the max(nums[2*i], nums[2*i+1])
Repeat until one number survives

Goal: Return the final survivor number after all tournament rounds.

Input & Output

example_1.py — Python

$ Input: [1,3,5,2,4,7,2,3]

› Output: 1

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

example_2.py — Python

$ Input: [3]

› Output: 3

💡 Note: Array already has length 1, so we return the only element: 3

example_3.py — Python

$ Input: [70,38,21,22]

› Output: 22

💡 Note: Round 1: [min(70,38)=38, max(21,22)=22] = [38,22]. Round 2: [min(38,22)=22] = [22]. Answer: 22

Constraints

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

Visualization

Tap to expand

Understanding the Visualization

Setup Tournament

Arrange all numbers in pairs for the first round

Apply Rules

Even positions take minimum, odd positions take maximum

Advance Winners

Winners form the next round's competitors

Repeat Until One

Continue until only one champion remains

Key Takeaway

🎯 Key Insight: This tournament simulation demonstrates how alternating competitive rules (min vs max) create a unique elimination pattern that always converges to a single winner in log(n) rounds.

Asked in

a Amazon 15 G Google 8 ⊞ Microsoft 5 Apple 3

This is a simulation problem that requires following the tournament rules exactly. The optimal approach is to simulate each round by creating new arrays and applying min/max rules based on index parity. Time complexity is O(n) since we process 2n total elements across all rounds.

Common Approaches

Approach	Time	Space	Notes
✓ Simulation with New Arrays	O(n)	O(n)	Create new arrays for each tournament round until one element remains

Simulation with New Arrays — Algorithm Steps

While array length > 1, create a new array of half the size
For each position i in new array, check if i is even or odd
If even: newArray[i] = min(nums[2*i], nums[2*i+1])
If odd: newArray[i] = max(nums[2*i], nums[2*i+1])
Replace original array with new array and repeat

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial Array

Start with array of length 2^k

Round 1

Apply min/max rules based on even/odd positions

Round 2

Continue with half-size array

Final Winner

Last remaining element is the answer

Code -

solution.c — C

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

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

int main() {
    int size = 0;
    int* nums = (int*)malloc(1000 * sizeof(int));
    char c;
    scanf("%c", &c); // '['
    while (scanf("%d", &nums[size]) == 1) {
        size++;
        scanf("%c", &c); // ',' or ']'
        if (c == ']') break;
    }
    printf("%d\n", minMaxGame(nums, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We process n + n/2 + n/4 + ... + 1 elements total, which sums to O(2n) = O(n)

✓ Linear Growth

Space Complexity

O(n)

We create new arrays for each round, using O(n/2) space in the worst case

⚡ Linearithmic Space

28.0K Views

Medium Frequency

~8 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

Simulation with New Arrays — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler