Sequentially Ordinal Rank Tracker - Practice Coding Problems

Sequentially Ordinal Rank Tracker - Problem

Design a Dynamic Location Ranking System

Imagine you're building a travel app that tracks scenic locations and their popularity in real-time! You need to create a SORTracker (Sequentially Ordinal Rank Tracker) system that manages location rankings dynamically.

How it works:
• Each scenic location has a name (unique string) and an attractiveness score (integer)
• Locations are ranked from best to worst: higher scores = better locations
• If two locations have the same score, the one with the lexicographically smaller name wins
• The system supports two operations:
1. add(name, score) - Add a new location to the system
2. get() - Return the i^th best location, where i = number of times get() has been called

Example: First call to get() returns 1st best location, second call returns 2nd best, third call returns 3rd best, and so on.

Your task: Implement the SORTracker class that efficiently handles these operations while maintaining the correct ranking order.

Input & Output

example_1.py — Basic Usage

$ Input: ["SORTracker", "add", "add", "get", "add", "get", "add", "get", "add", "get", "get", "get"] [[], ["bradford", 2], ["branford", 3], [], ["alps", 2], [], ["orland", 2], [], ["orlando", 3], [], [], []]

› Output: [null, null, null, "branford", null, "alps", null, "bradford", null, "bradford", "branford", "orlando"]

💡 Note: The tracker processes locations and queries sequentially. After adding bradford(2) and branford(3), the 1st query returns branford (highest score). After adding alps(2), the 2nd query returns alps (same score as bradford, but lexicographically smaller). The pattern continues with each query returning the i-th best location.

example_2.py — Tie Breaking

$ Input: ["SORTracker", "add", "add", "add", "get", "get", "get"] [[], ["zoo", 5], ["apple", 5], ["banana", 5], [], [], []]

› Output: [null, null, null, null, "apple", "banana", "zoo"]

💡 Note: When all locations have the same score (5), tie-breaking is done lexicographically. The queries return locations in alphabetical order: apple, banana, zoo.

example_3.py — Mixed Scores

$ Input: ["SORTracker", "add", "get", "add", "get", "add", "get"] [[], ["mountain", 8], [], ["beach", 9], [], ["forest", 7], []]

› Output: [null, null, "mountain", null, "beach", null, "mountain"]

💡 Note: First query returns mountain (only location). After adding beach(9), second query returns beach (highest score). After adding forest(7), third query returns mountain (second best after beach).

Constraints

1 ≤ name.length ≤ 10
name consists of lowercase English letters
1 ≤ score ≤ 10⁶
At most 4 × 10⁴ calls will be made to add and get
At any time, the number of calls to get does not exceed the number of calls to add

Visualization

Tap to expand

Understanding the Visualization

Set Up Two Lists

Keep a 'Winners Announced' list (max heap) and 'Nominees Waiting' list (min heap)

New Nomination Arrives

Compare with current boundary and place in appropriate list

Announce Next Winner

Take from 'Winners Announced' list and adjust boundary

Rebalance Lists

Move top nominee to winners list to maintain correct boundary

Key Takeaway

🎯 Key Insight: By maintaining two heaps separated by a dynamic boundary, we can efficiently track the k-th best element in a streaming dataset without expensive sorting operations.

Asked in

G Google 42 a Amazon 38 Apple 35 f Meta 29 ⊞ Microsoft 24

The optimal solution uses two heaps to maintain a dynamic boundary between top locations and remaining locations. A max heap stores the current top k locations (where k is the number of queries made), while a min heap stores the remaining locations. This allows O(log n) complexity for both add and get operations, making it much more efficient than sorting the entire list on every query.

Common Approaches

Approach	Time	Space	Notes
✓ Two Heaps (Optimal)	O(log n)	O(n)	Use max heap for top locations and min heap for remaining, maintaining dynamic boundary
Brute Force (Sort on Every Query)	O(q × n log n)	O(n)	Store all locations in a list and sort completely on every get() call

Two Heaps (Optimal) — Algorithm Steps

Initialize max heap (for top locations) and min heap (for remaining locations)
Keep track of current query number
On add(): Insert location into appropriate heap based on current boundary
On get(): Return top of max heap, then rebalance heaps by moving boundary
Maintain heap sizes so max heap has exactly 'query_number' elements

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Both heaps empty, query count = 0

Add Locations

Locations distributed between heaps maintaining boundary

First Query

Return top of max heap, increment boundary

Rebalance

Move element from min heap to max heap to maintain boundary

Code -

solution.c — C

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

#define MAX_SIZE 50000

typedef struct {
    char name[101];
    int score;
} Location;

typedef struct {
    Location heap[MAX_SIZE];
    int size;
    int isMaxHeap;
} Heap;

typedef struct {
    Heap maxHeap;
    Heap minHeap;
    int queryCount;
} SORTracker;

int compareLocation(Location a, Location b, int isMaxHeap) {
    if (a.score != b.score) {
        return isMaxHeap ? (a.score < b.score) : (a.score > b.score);
    }
    int nameComp = strcmp(a.name, b.name);
    return isMaxHeap ? (nameComp > 0) : (nameComp < 0);
}

void heapifyUp(Heap* h, int idx) {
    while (idx > 0) {
        int parent = (idx - 1) / 2;
        if (!compareLocation(h->heap[idx], h->heap[parent], h->isMaxHeap)) break;
        
        Location temp = h->heap[idx];
        h->heap[idx] = h->heap[parent];
        h->heap[parent] = temp;
        idx = parent;
    }
}

void heapifyDown(Heap* h, int idx) {
    while (1) {
        int smallest = idx;
        int left = 2 * idx + 1;
        int right = 2 * idx + 2;
        
        if (left < h->size && compareLocation(h->heap[left], h->heap[smallest], h->isMaxHeap)) {
            smallest = left;
        }
        if (right < h->size && compareLocation(h->heap[right], h->heap[smallest], h->isMaxHeap)) {
            smallest = right;
        }
        if (smallest == idx) break;
        
        Location temp = h->heap[idx];
        h->heap[idx] = h->heap[smallest];
        h->heap[smallest] = temp;
        idx = smallest;
    }
}

void heapPush(Heap* h, Location loc) {
    h->heap[h->size] = loc;
    h->size++;
    heapifyUp(h, h->size - 1);
}

Location heapPop(Heap* h) {
    Location result = h->heap[0];
    h->heap[0] = h->heap[h->size - 1];
    h->size--;
    if (h->size > 0) heapifyDown(h, 0);
    return result;
}

SORTracker* sorTrackerCreate() {
    SORTracker* tracker = malloc(sizeof(SORTracker));
    tracker->maxHeap.size = 0;
    tracker->maxHeap.isMaxHeap = 1;
    tracker->minHeap.size = 0;
    tracker->minHeap.isMaxHeap = 0;
    tracker->queryCount = 0;
    return tracker;
}

void sorTrackerAdd(SORTracker* obj, char* name, int score) {
    Location loc;
    strcpy(loc.name, name);
    loc.score = score;
    
    heapPush(&obj->minHeap, loc);
    Location top = heapPop(&obj->minHeap);
    heapPush(&obj->maxHeap, top);
    
    if (obj->maxHeap.size > obj->queryCount) {
        Location top = heapPop(&obj->maxHeap);
        heapPush(&obj->minHeap, top);
    }
}

char* sorTrackerGet(SORTracker* obj) {
    obj->queryCount++;
    
    if (obj->maxHeap.size < obj->queryCount && obj->minHeap.size > 0) {
        Location top = heapPop(&obj->minHeap);
        heapPush(&obj->maxHeap, top);
    }
    
    return obj->maxHeap.heap[0].name;
}

Time & Space Complexity

Time Complexity

⏱️

O(log n)

Each add() and get() operation involves heap operations which are O(log n)

⚡ Linearithmic

Space Complexity

O(n)

Store all n locations across two heaps

⚡ Linearithmic Space

43.2K Views

Medium-High Frequency

~25 min Avg. Time

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

Two Heaps (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler