Alt and Tab Simulation

Alt and Tab Simulation - Problem

There are n windows open numbered from 1 to n. We want to simulate using Alt + Tab to navigate between the windows.

You are given an array windows which contains the initial order of the windows (the first element is at the top and the last one is at the bottom).

You are also given an array queries where for each query, the window queries[i] is brought to the top.

Return the final state of the array windows after all queries are processed.

Input & Output

Example 1 — Basic Alt+Tab Simulation

$ Input: windows = [1,2,3], queries = [3,1,3]

› Output: [3,1,2]

💡 Note: Start with [1,2,3]. Query 3 moves it to front: [3,1,2]. Query 1 moves it to front: [1,3,2]. Query 3 moves it to front: [3,1,2].

Example 2 — Single Query

$ Input: windows = [1,2,3,4,5], queries = [4]

› Output: [4,1,2,3,5]

💡 Note: Only window 4 is queried, so it moves to the front while others maintain their relative order.

Example 3 — Multiple Same Queries

$ Input: windows = [2,1,3], queries = [1,1,1]

› Output: [1,2,3]

💡 Note: Window 1 is brought to front on first query [1,2,3], subsequent queries of same window don't change the order.

Constraints

1 ≤ windows.length ≤ 10³
1 ≤ queries.length ≤ 10⁵
1 ≤ windows[i], queries[i] ≤ 10⁶
All elements in windows are unique
All queries[i] exist in windows

Visualization

Tap to expand

Asked in

M Microsoft 35 G Google 28 🍎 Apple 22

The key insight is that Alt+Tab simulation can be optimized by processing queries in reverse order to avoid expensive array operations. The brute force approach directly simulates each move with O(n×m) time complexity. The optimal reverse processing approach constructs the final result in O(n+m) time by determining the final position of each window without intermediate moves. Time: O(n+m), Space: O(n+m).

Common Approaches

✓ Brute Force Simulation

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

For each query, search through the windows array to find the target window, remove it from its current position, and insert it at the front. This mimics exactly how Alt+Tab works in real operating systems.

Hash Map with Position Tracking

⏱️ Time: O(n × m) Space: O(n)

Maintain a hash map to track the current position of each window, allowing O(1) lookups instead of O(n) searches. Update positions after each move to keep the map accurate.

Reverse Processing

⏱️ Time: O(n + m) Space: O(n + m)

Instead of moving windows during queries, process queries in reverse order to determine the final position of each window. This avoids the expensive array shifting operations by building the result directly.

Brute Force Simulation — Algorithm Steps

For each query window
Find its current position in array
Remove it from current position
Insert it at the beginning

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Windows in original order

Process Query

Find and move window to front

Final State

All queries processed

Code -

solution.c — C

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

int* solution(int* windows, int windowsSize, int* queries, int queriesSize, int* returnSize) {
    int* result = (int*)malloc(windowsSize * sizeof(int));
    for (int i = 0; i < windowsSize; i++) {
        result[i] = windows[i];
    }
    *returnSize = windowsSize;
    
    for (int q = 0; q < queriesSize; q++) {
        int query = queries[q];
        
        // Find the window
        for (int i = 0; i < *returnSize; i++) {
            if (result[i] == query) {
                // Shift elements to remove current position
                for (int j = i; j > 0; j--) {
                    result[j] = result[j-1];
                }
                // Place at beginning
                result[0] = query;
                break;
            }
        }
    }
    
    return result;
}

int* parseArray(char* str, int* size) {
    int* arr = (int*)malloc(100 * sizeof(int));
    *size = 0;
    
    char* token = strtok(str, "[],");
    while (token != NULL) {
        arr[*size] = atoi(token);
        (*size)++;
        token = strtok(NULL, "[],");
    }
    
    return arr;
}

int main() {
    char line1[1000], line2[1000];
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    
    line1[strcspn(line1, "\n")] = 0;
    line2[strcspn(line2, "\n")] = 0;
    
    int windowsSize, queriesSize;
    int* windows = parseArray(line1, &windowsSize);
    int* queries = parseArray(line2, &queriesSize);
    
    int returnSize;
    int* result = solution(windows, windowsSize, queries, queriesSize, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(windows);
    free(queries);
    free(result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × m)

For each of m queries, we search through n windows and shift array elements

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for variables

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~15 min Avg. Time

847 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 Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler