Winner of the Linked List Game - Problem

Linked List Easy

You are given the head of a linked list of even length containing integers.

Each odd-indexed node contains an odd integer and each even-indexed node contains an even integer.

We call each even-indexed node and its next node a pair. For example:

Nodes with indices 0 and 1 are a pair
Nodes with indices 2 and 3 are a pair
And so on...

For every pair, we compare the values:

If the odd-indexed node value is higher → "Odd" team gets a point
If the even-indexed node value is higher → "Even" team gets a point

Return the name of the team with the higher points. If the points are equal, return "Tie".

Input & Output

Example 1 — Basic Case

$ Input: head = [2,7,4,9]

› Output: Odd

💡 Note: Pair 1: (2,7) → 7 > 2, Odd gets 1 point. Pair 2: (4,9) → 9 > 4, Odd gets 1 point. Final score: Even=0, Odd=2, so Odd wins.

Example 2 — Even Team Wins

$ Input: head = [8,3,6,1]

› Output: Even

💡 Note: Pair 1: (8,3) → 8 > 3, Even gets 1 point. Pair 2: (6,1) → 6 > 1, Even gets 1 point. Final score: Even=2, Odd=0, so Even wins.

Example 3 — Tie Game

$ Input: head = [10,5,2,7]

› Output: Tie

💡 Note: Pair 1: (10,5) → 10 > 5, Even gets 1 point. Pair 2: (2,7) → 7 > 2, Odd gets 1 point. Final score: Even=1, Odd=1, so it's a Tie.

Constraints

The linked list has even length
2 ≤ length ≤ 100
Each odd-indexed node contains an odd integer
Each even-indexed node contains an even integer
1 ≤ Node.val ≤ 100

Visualization

Tap to expand

Asked in

M Microsoft 15 a Amazon 12 G Google 8

The key insight is to traverse the linked list in pairs, comparing adjacent even-odd nodes and tracking team scores. The optimal approach uses a single pass with O(n) time and O(1) space complexity.

Common Approaches

✓ Score Difference Tracking

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

Instead of maintaining separate counters for both teams, we can track just the difference between scores. Increment for Even wins, decrement for Odd wins, then check the final difference sign.

Single Pass Traversal

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

Iterate through the linked list in pairs (even-odd indices), compare the values in each pair, and maintain running totals for both teams. Return the team with higher score or "Tie" if equal.

Score Difference Tracking — Algorithm Steps

Step 1: Initialize score difference to 0
Step 2: For each pair, increment difference if Even wins, decrement if Odd wins
Step 3: Determine winner based on final difference sign

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Set score difference to 0

Update Difference

+1 for Even wins, -1 for Odd wins

Final Decision

Positive = Even wins, Negative = Odd wins, Zero = Tie

Code -

solution.c — C

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

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

char* solution(struct ListNode* head) {
    int scoreDiff = 0;  // positive = Even ahead, negative = Odd ahead
    
    struct ListNode* current = head;
    while (current && current->next) {
        int evenVal = current->val;      // even index
        int oddVal = current->next->val;  // odd index
        
        if (evenVal > oddVal) {
            scoreDiff++;
        } else {
            scoreDiff--;
        }
        
        current = current->next->next;  // move to next pair
    }
    
    char* result = malloc(5);
    if (scoreDiff > 0) {
        strcpy(result, "Even");
    } else if (scoreDiff < 0) {
        strcpy(result, "Odd");
    } else {
        strcpy(result, "Tie");
    }
    return result;
}

struct ListNode* buildLinkedList(int* arr, int size) {
    if (size == 0) return NULL;
    struct ListNode* head = malloc(sizeof(struct ListNode));
    head->val = arr[0];
    head->next = NULL;
    
    struct ListNode* current = head;
    for (int i = 1; i < size; i++) {
        current->next = malloc(sizeof(struct ListNode));
        current->next->val = arr[i];
        current->next->next = NULL;
        current = current->next;
    }
    return head;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Simple array parsing for [a,b,c,d] format
    int arr[100];
    int size = 0;
    char* token = strtok(line, "[],\n");
    while (token != NULL) {
        arr[size++] = atoi(token);
        token = strtok(NULL, "[],\n");
    }
    
    struct ListNode* head = buildLinkedList(arr, size);
    char* result = solution(head);
    printf("%s\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single traversal through all n nodes in the linked list

✓ Linear Growth

Space Complexity

O(1)

Only using one integer for score difference tracking

✓ Linear Space

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

Winner of the Linked List Game - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Score Difference Tracking — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler