Output Contest Matches - Practice Coding Problems

Output Contest Matches - Problem

Imagine organizing the NBA playoffs where excitement comes from strategic team pairings! 🏀

You're given n teams ranked from 1 (strongest) to n (weakest). Your task is to create tournament brackets following this strategy: always pair the strongest remaining team with the weakest remaining team.

Goal: Return the final contest matches as a properly formatted string using:

() parentheses for team pairings
, commas to separate different matchups

Example: With 4 teams [1,2,3,4], team 1 pairs with team 4, and team 2 pairs with team 3, resulting in "((1,4),(2,3))"

The pairing continues recursively until only one final match remains!

Input & Output

example_1.py — Small Tournament

$ Input: n = 4

› Output: "((1,4),(2,3))"

💡 Note: Teams 1,2,3,4 get paired as: strongest(1) with weakest(4), second-strongest(2) with second-weakest(3), resulting in matches (1,4) and (2,3). These two matches form the final bracket.

example_2.py — Larger Tournament

$ Input: n = 8

› Output: "(((1,8),(4,5)),((2,7),(3,6)))"

💡 Note: First round: (1,8), (2,7), (3,6), (4,5). Second round: ((1,8),(4,5)) and ((2,7),(3,6)). Final bracket combines these two semi-final matches.

example_3.py — Minimum Case

$ Input: n = 2

› Output: "(1,2)"

💡 Note: With only 2 teams, there's just one match: strongest team 1 vs weakest team 2.

Constraints

2 ≤ n ≤ 2¹²
n is a power of 2 (ensures perfect tournament brackets)
Teams are numbered from 1 to n where 1 is strongest

Visualization

Tap to expand

Understanding the Visualization

Initial Setup

Start with n teams ranked 1 (strongest) to n (weakest)

Strategic Pairing

Pair team 1 with team n, team 2 with team (n-1), etc.

Build Brackets

Create match strings and repeat until final bracket

Final Result

Return the complete tournament bracket structure

Key Takeaway

🎯 Key Insight: Tournament brackets naturally follow a recursive structure where each round reduces participants by half, making recursion the perfect solution approach!

Asked in

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

This tournament bracket problem is best solved using recursive simulation. The key insight is that each round pairs the strongest remaining team with the weakest, reducing the field by half. The optimal approach uses recursion to naturally handle the tournament structure, achieving O(n) time complexity and O(log n) space complexity for the recursion stack.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (String Manipulation)	O(n log n)	O(n)	Repeatedly build new team list by pairing and concatenating strings
Recursive Simulation (Optimal)	O(n)	O(log n)	Recursively build tournament brackets by pairing teams optimally

Brute Force (String Manipulation) — Algorithm Steps

Initialize teams as individual strings: ['1', '2', '3', '4']
For each round, create pairs: (first, last), (second, second-last)
Build new list with paired teams as single strings
Repeat until only one final match string remains

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial Teams

Start with teams 1, 2, 3, 4

First Round Pairing

Pair (1,4) and (2,3)

Final Match

Create final bracket ((1,4),(2,3))

Code -

solution.c — C

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

char* findContestMatch(int n) {
    char teams[20][1000];  // Store team strings
    int teamCount = n;
    
    // Initialize teams as strings
    for (int i = 0; i < n; i++) {
        sprintf(teams[i], "%d", i + 1);
    }
    
    // Keep pairing until only one match remains
    while (teamCount > 1) {
        int nextCount = 0;
        char nextRound[20][1000];
        
        // Pair first with last, second with second-last, etc.
        for (int i = 0; i < teamCount / 2; i++) {
            sprintf(nextRound[nextCount], "(%s,%s)", teams[i], teams[teamCount - 1 - i]);
            nextCount++;
        }
        
        // Copy back to teams array
        for (int i = 0; i < nextCount; i++) {
            strcpy(teams[i], nextRound[i]);
        }
        teamCount = nextCount;
    }
    
    char* result = malloc(strlen(teams[0]) + 1);
    strcpy(result, teams[0]);
    return result;
}

int main() {
    int n;
    scanf("%d", &n);
    char* result = findContestMatch(n);
    printf("%s\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Each round takes O(k) time for k teams, with log n rounds total

⚡ Linearithmic

Space Complexity

O(n)

Storing team strings and building result string

⚡ Linearithmic Space

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

Brute Force (String Manipulation) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler