Queries on a Permutation With Key - Practice Coding Problems

Queries on a Permutation With Key - Problem

Imagine you have a special list that starts as [1, 2, 3, ..., m] - a perfect sequence from 1 to m. Now, you're given a series of queries, and for each query, you need to:

Find where the queried number currently sits in your list (this position is your answer!)
Move that number to the front of the list, shifting everything else to the right

This creates a dynamic reordering system where frequently queried numbers bubble up to the front, similar to how a browser's history works or how an operating system manages recently used files.

Goal: Return an array containing the position (0-indexed) where each queried number was found before moving it to the front.

Example: If you start with [1,2,3,4,5] and query 3, you'll find it at position 2, then your list becomes [3,1,2,4,5].

Input & Output

example_1.py — Basic Example

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

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

💡 Note: Starting with [1,2,3,4,5]: Query 3→found at index 2, becomes [3,1,2,4,5]. Query 1→found at index 1, becomes [1,3,2,4,5]. Query 2→found at index 2, becomes [2,1,3,4,5]. Query 1→found at index 1, becomes [1,2,3,4,5].

example_2.py — Single Query

$ Input: queries = [4], m = 4

› Output: [3]

💡 Note: Starting with [1,2,3,4]: Query 4 is found at index 3, so we return [3]. The array becomes [4,1,2,3].

example_3.py — Repeated Same Query

$ Input: queries = [2,2,2], m = 3

› Output: [1,0,0]

💡 Note: Starting with [1,2,3]: First query 2→found at index 1, becomes [2,1,3]. Second query 2→found at index 0, stays [2,1,3]. Third query 2→found at index 0, stays [2,1,3].

Constraints

1 ≤ queries.length ≤ 2×10⁴
1 ≤ queries[i] ≤ m
1 ≤ m ≤ 10³
All elements in queries are valid indices (between 1 and m inclusive)

Visualization

Tap to expand

Understanding the Visualization

Initialize

Start with ordered list [1,2,3,4,5]

Query 3

Find 3 at position 2, record answer, move to front

Query 1

Find 1 at position 1 in new list [3,1,2,4,5], move to front

Pattern

Recently queried elements stay near the front, affecting future query positions

Key Takeaway

🎯 Key Insight: This is essentially a move-to-front transform where each access moves an element to position 0, creating a self-organizing list where frequently accessed items naturally migrate toward the front.

Asked in

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

This problem can be solved using direct simulation with O(n²) complexity, or optimized using Binary Indexed Tree or Segment Tree for O(n log m) complexity. The key insight is that we're tracking dynamic positions in a list where elements move to front upon access, similar to a move-to-front transform used in data compression.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Simulation	O(n²)	O(m)	Directly simulate the process with array operations

Brute Force Simulation — Algorithm Steps

Initialize permutation array P = [1, 2, 3, ..., m]
For each query value q, scan P to find its current position
Record this position as the answer for this query
Remove q from its current position
Insert q at the beginning of P
Repeat for all queries

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with permutation [1,2,3,4,5]

Query 3

Find 3 at position 2, move to front: [3,1,2,4,5]

Query 1

Find 1 at position 1, move to front: [1,3,2,4,5]

Code -

solution.c — C

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

void processQueries(int* queries, int queriesSize, int m, int* result) {
    int* permutation = (int*)malloc(m * sizeof(int));
    for (int i = 0; i < m; i++) {
        permutation[i] = i + 1;
    }
    
    for (int i = 0; i < queriesSize; i++) {
        int query = queries[i];
        int position = -1;
        
        // Find position of query
        for (int j = 0; j < m; j++) {
            if (permutation[j] == query) {
                position = j;
                break;
            }
        }
        
        result[i] = position;
        
        // Move element to front
        for (int j = position; j > 0; j--) {
            permutation[j] = permutation[j-1];
        }
        permutation[0] = query;
    }
    
    free(permutation);
}

int main() {
    int queries[] = {3, 1, 2, 1};
    int queriesSize = 4;
    int m = 5;
    int* result = (int*)malloc(queriesSize * sizeof(int));
    
    processQueries(queries, queriesSize, m, result);
    
    for (int i = 0; i < queriesSize; i++) {
        printf("%d ", result[i]);
    }
    printf("\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of the n queries, we need O(m) time to find the element and O(m) time to move it to front

⚠ Quadratic Growth

Space Complexity

O(m)

We need to maintain the permutation array of size m

✓ Linear Space

28.4K Views

Medium Frequency

~25 min Avg. Time

890 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