Winner of the Linked List Game - Practice Coding Problems

Winner of the Linked List Game - Problem

Linked List Easy

Imagine a friendly competition between two teams: Team Even and Team Odd! You are given the head of a linked list with an even length containing integers.

The linked list follows a special pattern:

Each even-indexed node (positions 0, 2, 4, ...) contains an even integer
Each odd-indexed node (positions 1, 3, 5, ...) contains an odd integer

The game works like this: We group nodes into pairs - each even-indexed node pairs with its immediate next node. For example:

Nodes at indices 0 and 1 form a pair
Nodes at indices 2 and 3 form a pair
And so on...

For each pair, we compare the values:

If the odd-indexed node has a higher value → Team Odd gets 1 point
If the even-indexed node has a higher value → Team Even gets 1 point

Goal: Return the name of the team with more points. If both teams have equal points, return "Tie".

Input & Output

example_1.py — Basic Case

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

› Output: "Tie"

💡 Note: Pair 1: (2,3) → 3 > 2, Odd team gets 1 point. Pair 2: (4,1) → 4 > 1, Even team gets 1 point. Both teams have 1 point, so result is "Tie".

example_2.py — Even Team Wins

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

› Output: "Odd"

💡 Note: Pair 1: (4,5) → 5 > 4, Odd team gets 1 point. Pair 2: (2,1) → 2 > 1, Even team gets 1 point. Wait, let me recalculate: Odd team gets 1 point, Even team gets 1 point. Actually this should be "Tie" too. Let me fix: For Odd team to win, we need [2,5,4,1] → (2,5): Odd wins, (4,1): Even wins → Still tie. Let's use [2,7,4,3] → (2,7): Odd wins, (4,3): Even wins → Tie again. How about [2,5,4,7] → (2,5): Odd wins, (4,7): Odd wins → Odd team wins with 2 points.

example_3.py — Single Pair

$ Input: [6,1]

› Output: "Even"

💡 Note: Only one pair: (6,1) → 6 > 1, Even team gets 1 point and wins.

Visualization

Tap to expand

Understanding the Visualization

Setup Tournament

Initialize scoreboards for both teams and line up all player pairs

First Matchup

Compare the first Even player (index 0) with first Odd player (index 1)

Award Points

Give 1 point to the team whose player has the higher score

Next Matchup

Move to the next pair and repeat the comparison process

Declare Winner

After all matchups, the team with more points wins, or it's a tie

Key Takeaway

🎯 Key Insight: The linked list structure naturally provides us with pairs, so we only need one traversal to compare adjacent nodes and determine the winning team efficiently.

Time & Space Complexity

Time Complexity

⏱️

O(n)

We visit each node exactly once, where n is the number of nodes

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track scores and current position

✓ Linear Space

Constraints

The number of nodes in the list is in the range [2, 10⁴]
The list length is always even
1 ≤ Node.val ≤ 10⁵
Each odd-indexed node contains an odd integer
Each even-indexed node contains an even integer

Asked in

a Amazon 25 ⊞ Microsoft 18 G Google 15 f Meta 12

The optimal approach uses a single pass traversal of the linked list, comparing each pair of adjacent nodes in O(n) time and O(1) space. Since the problem structure naturally gives us pairs, we simply iterate through the list, compare each even-indexed node with its odd-indexed neighbor, and track scores for both teams.

Common Approaches

Approach	Time	Space	Notes
✓ Single Pass Traversal	O(n)	O(1)	Traverse the linked list once, comparing each pair of adjacent nodes

Single Pass Traversal — Algorithm Steps

Initialize counters for even and odd team scores
Start from the head of the linked list
While there are pairs remaining (current and current.next exist)
Compare current node (even team) with next node (odd team)
Increment the winning team's score
Move to the next pair (skip 2 nodes)
Return the team with higher score or "Tie"

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Scores

Start with Even Score = 0, Odd Score = 0

Compare First Pair

Compare node 0 (even) with node 1 (odd)

Award Point

Give point to winning team and move to next pair

Repeat Process

Continue until all pairs are processed

Determine Winner

Compare final scores and return result

Code -

solution.c — C

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

struct ListNode {
    int val;
    struct ListNode *next;
};

char* gameResult(struct ListNode* head) {
    int evenScore = 0;
    int oddScore = 0;
    
    struct ListNode* current = head;
    while (current && current->next) {
        int evenVal = current->val;      // Even-indexed node
        int oddVal = current->next->val; // Odd-indexed node
        
        if (evenVal > oddVal) {
            evenScore++;
        } else {
            oddScore++;
        }
        
        // Move to next pair
        current = current->next->next;
    }
    
    char* result = (char*)malloc(5 * sizeof(char));
    if (evenScore > oddScore) {
        strcpy(result, "Even");
    } else if (oddScore > evenScore) {
        strcpy(result, "Odd");
    } else {
        strcpy(result, "Tie");
    }
    
    return result;
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    // Simple parsing for demo
    struct ListNode* head = (struct ListNode*)malloc(sizeof(struct ListNode));
    head->val = 2;
    head->next = (struct ListNode*)malloc(sizeof(struct ListNode));
    head->next->val = 3;
    head->next->next = (struct ListNode*)malloc(sizeof(struct ListNode));
    head->next->next->val = 4;
    head->next->next->next = (struct ListNode*)malloc(sizeof(struct ListNode));
    head->next->next->next->val = 1;
    head->next->next->next->next = NULL;
    
    char* result = gameResult(head);
    printf("%s\n", result);
    free(result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We visit each node exactly once, where n is the number of nodes

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track scores and current position

✓ Linear Space

Constraints

The number of nodes in the list is in the range [2, 10⁴]
The list length is always even
1 ≤ Node.val ≤ 10⁵
Each odd-indexed node contains an odd integer
Each even-indexed node contains an even integer

28.5K Views

Medium Frequency

~15 min Avg. Time

892 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Single Pass Traversal — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler