Elimination Game

Elimination Game - Problem

Math Recursion Medium

You have a list arr of all integers in the range [1, n] sorted in a strictly increasing order. Apply the following algorithm on arr:

Starting from left to right, remove the first number and every other number afterward until you reach the end of the list.

Repeat the previous step again, but this time from right to left, remove the rightmost number and every other number from the remaining numbers.

Keep repeating the steps again, alternating left to right and right to left, until a single number remains.

Given the integer n, return the last number that remains in arr.

Input & Output

Example 1 — Small Case

$ Input: n = 9

› Output: 6

💡 Note: arr = [1,2,3,4,5,6,7,8,9]. Round 1 (L→R): remove 1,3,5,7,9 → [2,4,6,8]. Round 2 (R→L): remove 8,4 → [2,6]. Round 3 (L→R): remove 2 → [6].

Example 2 — Even Number

$ Input: n = 10

› Output: 8

💡 Note: arr = [1,2,3,4,5,6,7,8,9,10]. Round 1 (L→R): remove 1,3,5,7,9 → [2,4,6,8,10]. Round 2 (R→L): remove 10,6,2 → [4,8]. Round 3 (L→R): remove 4 → [8].

Example 3 — Minimum Case

$ Input: n = 1

› Output: 1

💡 Note: Only one element [1], no elimination needed, return 1.

Constraints

1 ≤ n ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 35 M Microsoft 28 A Amazon 22

The key insight is to track only the first remaining element and step size instead of simulating the entire array. The mathematical pattern approach achieves O(log n) time and O(1) space by recognizing that we only need to update the first element when going left-to-right or when the remaining count is odd.

Common Approaches

✓ Mathematical Pattern

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

Instead of simulating the entire array, we track only the first remaining element and the step size. Each elimination round doubles the step size, and we update the first element based on the direction.

Simulation

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

Create the array [1, 2, ..., n] and repeatedly eliminate elements by removing every other element, alternating between left-to-right and right-to-left directions until only one element remains.

Mathematical Pattern — Algorithm Steps

Initialize first=1, step=1, remaining=n, leftToRight=true
While remaining > 1
If going left-to-right or odd remaining, update first
Double the step size
Halve remaining elements
Toggle direction

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

first=1, step=1, remaining=10, leftToRight=true

Round 1

first=1+1=2, step=2, remaining=5, leftToRight=false

Round 2

first=2+2=4, step=4, remaining=2, leftToRight=true

Result

first=4+4=8, remaining=1, return 8

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <cjson/cJSON.h>

#define MAX_EVENTS 100
#define MAX_CALLBACKS 100

typedef struct CallbackEntry {
    int id;
    int (*callback)(int*, int);
    int active;
} CallbackEntry;

typedef struct EventEntry {
    char name[100];
    CallbackEntry callbacks[MAX_CALLBACKS];
    int callbackCount;
    int active;
} EventEntry;

typedef struct EventEmitter {
    EventEntry events[MAX_EVENTS];
    int eventCount;
    int nextId;
} EventEmitter;

int callback1(int* args, int argc) { return 1; }
int callback2(int* args, int argc) { return 2; }
int callbackX(int* args, int argc) { return argc > 0 ? args[0] : 0; }

EventEmitter* createEventEmitter() {
    EventEmitter* emitter = malloc(sizeof(EventEmitter));
    emitter->eventCount = 0;
    emitter->nextId = 0;
    return emitter;
}

int subscribe(EventEmitter* emitter, const char* eventName, int (*callback)(int*, int)) {
    int eventIndex = -1;
    
    // Find existing event or create new one
    for (int i = 0; i < emitter->eventCount; i++) {
        if (emitter->events[i].active && strcmp(emitter->events[i].name, eventName) == 0) {
            eventIndex = i;
            break;
        }
    }
    
    if (eventIndex == -1) {
        eventIndex = emitter->eventCount++;
        strcpy(emitter->events[eventIndex].name, eventName);
        emitter->events[eventIndex].callbackCount = 0;
        emitter->events[eventIndex].active = 1;
    }
    
    int subscriptionId = emitter->nextId++;
    EventEntry* event = &emitter->events[eventIndex];
    
    event->callbacks[event->callbackCount].id = subscriptionId;
    event->callbacks[event->callbackCount].callback = callback;
    event->callbacks[event->callbackCount].active = 1;
    event->callbackCount++;
    
    return subscriptionId;
}

void unsubscribe(EventEmitter* emitter, int id) {
    for (int i = 0; i < emitter->eventCount; i++) {
        if (!emitter->events[i].active) continue;
        EventEntry* event = &emitter->events[i];
        for (int j = 0; j < event->callbackCount; j++) {
            if (event->callbacks[j].id == id) {
                event->callbacks[j].active = 0;
                return;
            }
        }
    }
}

int* emit(EventEmitter* emitter, const char* eventName, int* args, int argc, int* resultCount) {
    int* results = malloc(MAX_CALLBACKS * sizeof(int));
    *resultCount = 0;
    
    for (int i = 0; i < emitter->eventCount; i++) {
        if (emitter->events[i].active && strcmp(emitter->events[i].name, eventName) == 0) {
            EventEntry* event = &emitter->events[i];
            for (int j = 0; j < event->callbackCount; j++) {
                if (event->callbacks[j].active) {
                    results[(*resultCount)++] = event->callbacks[j].callback(args, argc);
                }
            }
            break;
        }
    }
    
    return results;
}

int (*parseCallback(const char* callbackStr))(int*, int) {
    if (strcmp(callbackStr, "() => 1") == 0) return callback1;
    if (strcmp(callbackStr, "() => 2") == 0) return callback2;
    if (strcmp(callbackStr, "(x) => x") == 0) return callbackX;
    return callback1;
}

char* solution(const char* operations) {
    cJSON* json = cJSON_Parse(operations);
    if (!json) return strdup("[]");
    
    EventEmitter* emitter = createEventEmitter();
    cJSON* results = cJSON_CreateArray();
    int* subscriptions = malloc(100 * sizeof(int));
    int subCount = 0;
    
    cJSON* op;
    cJSON_ArrayForEach(op, json) {
        cJSON* action = cJSON_GetArrayItem(op, 0);
        if (!action || !cJSON_IsString(action)) continue;
        
        if (strcmp(action->valuestring, "subscribe") == 0) {
            cJSON* eventName = cJSON_GetArrayItem(op, 1);
            cJSON* callbackStr = cJSON_GetArrayItem(op, 2);
            if (eventName && callbackStr && cJSON_IsString(eventName) && cJSON_IsString(callbackStr)) {
                int (*callback)(int*, int) = parseCallback(callbackStr->valuestring);
                int subId = subscribe(emitter, eventName->valuestring, callback);
                subscriptions[subCount++] = subId;
            }
        } else if (strcmp(action->valuestring, "emit") == 0) {
            cJSON* eventName = cJSON_GetArrayItem(op, 1);
            if (eventName && cJSON_IsString(eventName)) {
                int args[10] = {0};
                int argc = 0;
                cJSON* argsArray = cJSON_GetArrayItem(op, 2);
                if (argsArray && cJSON_IsArray(argsArray)) {
                    cJSON* arg;
                    cJSON_ArrayForEach(arg, argsArray) {
                        if (cJSON_IsNumber(arg) && argc < 10) {
                            args[argc++] = (int)arg->valuedouble;
                        }
                    }
                }
                
                int resultCount;
                int* emitResults = emit(emitter, eventName->valuestring, args, argc, &resultCount);
                
                cJSON* resultArray = cJSON_CreateArray();
                for (int i = 0; i < resultCount; i++) {
                    cJSON_AddItemToArray(resultArray, cJSON_CreateNumber(emitResults[i]));
                }
                cJSON_AddItemToArray(results, resultArray);
                free(emitResults);
            }
        } else if (strcmp(action->valuestring, "unsubscribe") == 0) {
            cJSON* index = cJSON_GetArrayItem(op, 1);
            if (index && cJSON_IsNumber(index)) {
                int idx = (int)index->valuedouble;
                if (idx >= 0 && idx < subCount) {
                    unsubscribe(emitter, subscriptions[idx]);
                }
            }
        }
    }
    
    char* result = cJSON_Print(results);
    cJSON_Delete(json);
    cJSON_Delete(results);
    free(subscriptions);
    free(emitter);
    
    return result;
}

int main() {
    char input[10000];
    fgets(input, sizeof(input), stdin);
    input[strcspn(input, "\n")] = 0;
    
    char* result = solution(input);
    printf("%s\n", result);
    free(result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(log n)

Each iteration eliminates half the remaining elements, so we need log n iterations

⚡ Linearithmic

Space Complexity

O(1)

Only stores a few integer variables regardless of input size

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~25 min Avg. Time

842 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

Mathematical Pattern — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler