Alt and Tab Simulation - Practice Coding Problems

Alt and Tab Simulation - Problem

Imagine you're working on multiple tasks on your computer with n windows open, numbered from 1 to n. Just like in real operating systems, you can use Alt+Tab to navigate between windows, which brings the selected window to the front (top of the stack).

You're given an array windows representing the initial order of windows, where the first element is at the top (most recently used) and the last element is at the bottom (least recently used).

You're also given an array queries where each queries[i] represents a window that gets brought to the top through Alt+Tab navigation.

Your task: Return the final state of the windows array after processing all queries, simulating the behavior of a window manager's Alt+Tab functionality.

Think of this as implementing the core logic behind your operating system's window switching mechanism!

Input & Output

example_1.py — Basic Window Switching

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

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

💡 Note: Initially: [1,2,3,4]. Query 3: move 3 to front → [3,1,2,4]. Query 1: move 1 to front → [1,3,2,4]. Query 2: move 2 to front → [2,1,3,4].

example_2.py — Single Query

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

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

💡 Note: Window 4 is at index 3. After bringing it to the front, the order becomes [4,5,3,1,2].

example_3.py — Already at Front

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

› Output: [2,1,3]

💡 Note: First query 1: already at front, no change. Second query 1: still at front. Query 2: move 2 to front → [2,1,3].

Visualization

Tap to expand

Understanding the Visualization

Initial Setup

Windows are stacked with most recent at the front

Alt+Tab Selection

User selects a window from the middle of the stack

Bring to Front

Selected window moves to the front, others shift back

Hash Map Optimization

Position tracking eliminates need to search through all windows

Key Takeaway

🎯 Key Insight: Using a hash map to track window positions transforms this from a searching problem into a direct access problem, mimicking how modern operating systems efficiently manage window switching!

Time & Space Complexity

Time Complexity

⏱️

O(n × m)

While lookup is O(1), we still need O(n) time to shift elements for each query. Total: O(m) queries × O(n) shifting = O(n×m)

✓ Linear Growth

Space Complexity

O(n)

Hash map stores the position of each of the n windows

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 10³
1 ≤ windows[i] ≤ n
All windows[i] are unique
1 ≤ queries.length ≤ 10³
1 ≤ queries[i] ≤ n
queries[i] will always exist in windows

Asked in

⊞ Microsoft 35 G Google 28 a Amazon 22 Apple 18

This problem simulates the Alt+Tab window switching mechanism. The optimal approach uses a hash map to track window positions, enabling O(1) lookups instead of linear searches. While we still need O(n) time to shift array elements for each query, the hash map optimization significantly improves performance for repeated queries and makes the solution more scalable.

Common Approaches

Approach	Time	Space	Notes
✓ Hash Map for Position Tracking (Optimal)	O(n × m)	O(n)	Use a hash map to track window positions for O(1) lookups and updates
Brute Force (Linear Search and Remove)	O(n × m)	O(1)	For each query, search through the array to find and move the window to front

Hash Map for Position Tracking (Optimal) — Algorithm Steps

Create a hash map to track the current position of each window
For each query, look up the window's current position in O(1) time
Move the window to the front and shift other windows accordingly
Update the position map for all affected windows

Visualization

Tap to expand

Step-by-Step Walkthrough

Position Map Created

HashMap: {1→0, 2→1, 3→2, 4→3}

O(1) Lookup

Query 3: positionMap.get(3) = 2

Move and Update

Move 3 to front, update all positions

Code -

solution.c — C

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

#define MAX_WINDOWS 1000

typedef struct {
    int window;
    int position;
} WindowPos;

int findWindow(WindowPos* map, int size, int window) {
    for (int i = 0; i < size; i++) {
        if (map[i].window == window) {
            return map[i].position;
        }
    }
    return -1;
}

void updatePositions(WindowPos* map, int size, int* windows) {
    for (int i = 0; i < size; i++) {
        for (int j = 0; j < size; j++) {
            if (map[i].window == windows[j]) {
                map[i].position = j;
                break;
            }
        }
    }
}

void altTabSimulation(int* windows, int windowsSize, int* queries, int queriesSize) {
    WindowPos positionMap[MAX_WINDOWS];
    
    // Initialize position map
    for (int i = 0; i < windowsSize; i++) {
        positionMap[i].window = windows[i];
        positionMap[i].position = i;
    }
    
    for (int q = 0; q < queriesSize; q++) {
        int query = queries[q];
        int currentPos = findWindow(positionMap, windowsSize, query);
        
        if (currentPos == 0) continue;
        
        // Move window to front
        int temp = windows[currentPos];
        for (int j = currentPos; j > 0; j--) {
            windows[j] = windows[j-1];
        }
        windows[0] = temp;
        
        // Update position map
        updatePositions(positionMap, windowsSize, windows);
    }
}

int main() {
    int windows[] = {1, 2, 3, 4};
    int queries[] = {3, 1, 2};
    int windowsSize = 4;
    int queriesSize = 3;
    
    altTabSimulation(windows, windowsSize, queries, queriesSize);
    
    printf("[");
    for (int i = 0; i < windowsSize; i++) {
        printf("%d", windows[i]);
        if (i < windowsSize - 1) printf(", ");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × m)

While lookup is O(1), we still need O(n) time to shift elements for each query. Total: O(m) queries × O(n) shifting = O(n×m)

✓ Linear Growth

Space Complexity

O(n)

Hash map stores the position of each of the n windows

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 10³
1 ≤ windows[i] ≤ n
All windows[i] are unique
1 ≤ queries.length ≤ 10³
1 ≤ queries[i] ≤ n
queries[i] will always exist in windows

23.4K Views

Medium Frequency

~15 min Avg. Time

856 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

Hash Map for Position Tracking (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler