Design Task Manager - Practice Coding Problems

Design Task Manager - Problem

You're building a Task Management System that handles tasks across multiple users, each with different priorities. Think of it like a sophisticated to-do list manager for a team where the system needs to efficiently track, modify, and execute tasks based on their importance.

Your system should support the following operations:

TaskManager(tasks) - Initialize with existing user-task-priority triples
add(userId, taskId, priority) - Add a new task to a user
edit(taskId, newPriority) - Update a task's priority
rmv(taskId) - Remove a task completely
execTop() - Execute the highest priority task (highest taskId breaks ties)

Key Challenge: When executing tasks, you need to find the highest priority task across all users. If multiple tasks have the same priority, pick the one with the highest taskId.

Example: If User 1 has task 100 (priority 5) and User 2 has task 200 (priority 5), executing the top task should return User 2 since task 200 > task 100.

Input & Output

basic_operations.py — Python

$ Input: TaskManager([[1, 101, 10], [2, 102, 20], [3, 103, 15]]) tm.add(1, 104, 25) tm.execTop() tm.edit(103, 30) tm.execTop()

› Output: [1, 3]

💡 Note: Initially we have tasks: T101(P10,U1), T102(P20,U2), T103(P15,U3). After adding T104(P25,U1), execTop() returns 1 (User1 owns highest priority task T104). After editing T103 to priority 30, execTop() returns 3 (User3 owns T103 with priority 30).

tie_breaking.py — Python

$ Input: TaskManager([[1, 50, 10], [2, 100, 10]]) tm.execTop()

› Output: 2

💡 Note: Both tasks have priority 10, but task 100 > task 50, so User2 wins the tie-breaker.

remove_and_empty.py — Python

$ Input: TaskManager([[1, 201, 5]]) tm.rmv(201) tm.execTop()

› Output: -1

💡 Note: After removing the only task, execTop() returns -1 since no tasks remain.

Constraints

1 ≤ tasks.length ≤ 10⁵
1 ≤ userId, taskId ≤ 10⁵
0 ≤ priority ≤ 10⁹
At most 2 × 10⁵ calls will be made to add, edit, rmv, and execTop
taskId is unique across the entire system
Guaranteed valid inputs for edit and rmv operations

Visualization

Tap to expand

Understanding the Visualization

Data Structures

Max heap for priority queue + hash map for fast lookups

Add Operation

Insert into both heap and hash map in O(log n) time

Edit Operation

Mark old entry invalid, add new entry with updated priority

Execute Top

Pop from heap, verify validity, return user ID

Key Takeaway

🎯 Key Insight: Combining heap for priority ordering with hash map for fast lookups gives us the best of both worlds - efficient priority operations and constant-time task management.

Asked in

G Google 42 a Amazon 38 ⊞ Microsoft 31 f Meta 25 Apple 18

The optimal solution uses a max heap combined with hash maps to achieve O(log n) execTop() operations. The heap maintains priority order while hash maps enable O(1) lookups. Lazy deletion handles removed/edited tasks efficiently by marking them invalid and cleaning up during heap operations.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Linear Search)	O(n)	O(n)	Store tasks in a simple list and search linearly for operations
Heap + Hash Map (Optimal)	O(log n)	O(n)	Use max heap for priority queue with hash maps for O(1) lookups

Brute Force (Linear Search) — Algorithm Steps

Store tasks as list of [userId, taskId, priority] tuples
For add(): append new task to list
For edit(): search list for taskId and update priority
For rmv(): search list for taskId and remove
For execTop(): scan entire list to find max priority task

Visualization

Tap to expand

Step-by-Step Walkthrough

Add Task

Simply append new task to end of list

Execute Top

Scan entire list to find highest priority task

Remove Task

Linear search and remove from list

Code -

solution.c — C

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

typedef struct {
    int** tasks;
    int size;
    int capacity;
} TaskManager;

TaskManager* taskManagerCreate(int** tasks, int tasksSize, int* tasksColSize) {
    TaskManager* tm = (TaskManager*)malloc(sizeof(TaskManager));
    tm->capacity = tasksSize + 100;
    tm->tasks = (int**)malloc(tm->capacity * sizeof(int*));
    tm->size = 0;
    
    for (int i = 0; i < tasksSize; i++) {
        tm->tasks[tm->size] = (int*)malloc(3 * sizeof(int));
        tm->tasks[tm->size][0] = tasks[i][0];
        tm->tasks[tm->size][1] = tasks[i][1];
        tm->tasks[tm->size][2] = tasks[i][2];
        tm->size++;
    }
    return tm;
}

void taskManagerAdd(TaskManager* obj, int userId, int taskId, int priority) {
    if (obj->size >= obj->capacity) {
        obj->capacity *= 2;
        obj->tasks = (int**)realloc(obj->tasks, obj->capacity * sizeof(int*));
    }
    obj->tasks[obj->size] = (int*)malloc(3 * sizeof(int));
    obj->tasks[obj->size][0] = userId;
    obj->tasks[obj->size][1] = taskId;
    obj->tasks[obj->size][2] = priority;
    obj->size++;
}

void taskManagerEdit(TaskManager* obj, int taskId, int newPriority) {
    for (int i = 0; i < obj->size; i++) {
        if (obj->tasks[i][1] == taskId) {
            obj->tasks[i][2] = newPriority;
            break;
        }
    }
}

void taskManagerRmv(TaskManager* obj, int taskId) {
    for (int i = 0; i < obj->size; i++) {
        if (obj->tasks[i][1] == taskId) {
            free(obj->tasks[i]);
            for (int j = i; j < obj->size - 1; j++) {
                obj->tasks[j] = obj->tasks[j + 1];
            }
            obj->size--;
            break;
        }
    }
}

int taskManagerExecTop(TaskManager* obj) {
    if (obj->size == 0) return -1;
    
    int maxPriority = -1;
    int maxTaskId = -1;
    int maxUserId = -1;
    int maxIndex = -1;
    
    for (int i = 0; i < obj->size; i++) {
        int userId = obj->tasks[i][0];
        int taskId = obj->tasks[i][1];
        int priority = obj->tasks[i][2];
        
        if (priority > maxPriority || (priority == maxPriority && taskId > maxTaskId)) {
            maxPriority = priority;
            maxTaskId = taskId;
            maxUserId = userId;
            maxIndex = i;
        }
    }
    
    if (maxIndex != -1) {
        free(obj->tasks[maxIndex]);
        for (int j = maxIndex; j < obj->size - 1; j++) {
            obj->tasks[j] = obj->tasks[j + 1];
        }
        obj->size--;
        return maxUserId;
    }
    return -1;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each operation requires scanning through all tasks

✓ Linear Growth

Space Complexity

O(n)

Store n tasks in a list

⚡ Linearithmic Space

73.9K Views

High Frequency

~32 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

Brute Force (Linear Search) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler