Design a Todo List

Design a Todo List - Problem

You need to design a comprehensive todo list system that supports multiple users and advanced task management features. Each user should be able to:

Add tasks with descriptions, due dates, and tags
Mark tasks as complete when finished
View pending tasks sorted by due date
Filter tasks by specific tags for better organization

Your TodoList class must efficiently handle concurrent users while maintaining data integrity and providing fast query responses.

Class Methods to Implement:

TodoList() - Initialize the todo list system
int addTask(int userId, String taskDescription, int dueDate, List<String> tags) - Add a new task and return its unique ID
List<String> getAllTasks(int userId) - Get all pending tasks for a user, ordered by due date
List<String> getTasksForTag(int userId, String tag) - Get pending tasks filtered by tag, ordered by due date
void completeTask(int userId, int taskId) - Mark a task as completed

Example Usage:

TodoList todoList = new TodoList();
int taskId = todoList.addTask(1, "Buy groceries", 20231201, ["shopping", "urgent"]);
todoList.getAllTasks(1); // Returns: ["Buy groceries"]
todoList.completeTask(1, taskId);
todoList.getAllTasks(1); // Returns: []

Input & Output

example_1.py — Basic Operations

$ Input: todoList = TodoList() taskId1 = todoList.addTask(1, "Buy groceries", 20231201, ["shopping", "urgent"]) taskId2 = todoList.addTask(1, "Walk the dog", 20231130, ["pets", "daily"]) print(todoList.getAllTasks(1)) print(todoList.getTasksForTag(1, "urgent"))

› Output: ["Walk the dog", "Buy groceries"] ["Buy groceries"]

💡 Note: Tasks are returned sorted by due date. Walk the dog (20231130) comes before Buy groceries (20231201). The tag filter returns only tasks with the 'urgent' tag.

example_2.py — Task Completion

$ Input: todoList = TodoList() taskId = todoList.addTask(1, "Finish project", 20231215, ["work"]) print(todoList.getAllTasks(1)) todoList.completeTask(1, taskId) print(todoList.getAllTasks(1))

› Output: ["Finish project"] []

💡 Note: After completing a task, it no longer appears in the pending tasks list returned by getAllTasks or getTasksForTag.

example_3.py — Multiple Users

$ Input: todoList = TodoList() todoList.addTask(1, "User 1 Task", 20231201, ["personal"]) todoList.addTask(2, "User 2 Task", 20231201, ["personal"]) print(todoList.getAllTasks(1)) print(todoList.getAllTasks(2)) print(todoList.getTasksForTag(2, "personal"))

› Output: ["User 1 Task"] ["User 2 Task"] ["User 2 Task"]

💡 Note: Each user has their own separate task list. Tasks are isolated by user ID, so user 1 only sees their tasks and user 2 only sees theirs.

Constraints

1 ≤ userId, taskId ≤ 100
0 ≤ dueDate ≤ 10⁸
1 ≤ taskDescription.length ≤ 50
0 ≤ tags.length ≤ 100
1 ≤ tags[i].length ≤ 10
At most 100 calls will be made to addTask
At most 100 calls will be made to getAllTasks
At most 100 calls will be made to getTasksForTag
At most 100 calls will be made to completeTask

Visualization

Tap to expand

LookupO(1) Tag
Filtering🎯 Multiple indexes enable O(1) access patterns for all query types

Understanding the Visualization

User Drawer

Each user has their own drawer with tasks sorted by due date

Tag Filing System

Cross-reference system where tasks are also filed by tag combinations

Central Registry

Master list of all task details with completion status

Quick Retrieval

Any query can be answered by going directly to the right drawer

Key Takeaway

🎯 Key Insight: By maintaining multiple specialized indexes (user-based and tag-based), we can answer any query in O(1) time plus the time to sort the specific user's tasks, which is much faster than scanning all tasks in the system.

Asked in

G Google 35 ⊞ Microsoft 28 a Amazon 25 f Meta 20

The optimal solution uses multiple hash tables to index tasks by user and tags, achieving O(1) lookup time for most operations. The key insight is maintaining separate indexes for user tasks and tag-filtered tasks while keeping task details in a central storage. This design pattern is commonly used in database indexing and real-time systems where fast queries are critical.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Linear Search)	O(n)	O(n)	Store all tasks in a single list and search linearly for each operation
Hash Table Optimization (Optimal)	O(1)	O(n * t)	Use multiple hash tables to index tasks by user and tags for O(1) access

Brute Force (Linear Search) — Algorithm Steps

Store all tasks in a single list with task metadata
For getAllTasks: iterate through all tasks, filter by userId and incomplete status
For getTasksForTag: iterate through all tasks, filter by userId, tag, and incomplete status
For completeTask: iterate to find the task and mark it complete
Sort results by due date before returning

Visualization

Tap to expand

Step-by-Step Walkthrough

Store Tasks

All tasks stored in single array

Linear Scan

Each query scans entire array

Filter Results

Apply filters during scan

Sort Output

Sort filtered results by due date

Code -

solution.c — C

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

#define MAX_TASKS 1000
#define MAX_TAGS 10
#define MAX_DESC_LEN 100
#define MAX_TAG_LEN 50

typedef struct {
    int id;
    int userId;
    char description[MAX_DESC_LEN];
    int dueDate;
    char tags[MAX_TAGS][MAX_TAG_LEN];
    int tagCount;
    bool completed;
} Task;

typedef struct {
    Task tasks[MAX_TASKS];
    int taskCount;
    int nextId;
} TodoList;

TodoList* todoListCreate() {
    TodoList* obj = (TodoList*)malloc(sizeof(TodoList));
    obj->taskCount = 0;
    obj->nextId = 1;
    return obj;
}

int todoListAddTask(TodoList* obj, int userId, char* taskDescription, int dueDate, char** tags, int tagsSize) {
    int taskId = obj->nextId++;
    Task* task = &obj->tasks[obj->taskCount];
    
    task->id = taskId;
    task->userId = userId;
    strcpy(task->description, taskDescription);
    task->dueDate = dueDate;
    task->tagCount = tagsSize;
    task->completed = false;
    
    for (int i = 0; i < tagsSize; i++) {
        strcpy(task->tags[i], tags[i]);
    }
    
    obj->taskCount++;
    return taskId;
}

int compareByDueDate(const void* a, const void* b) {
    Task* taskA = (Task*)a;
    Task* taskB = (Task*)b;
    return taskA->dueDate - taskB->dueDate;
}

char** todoListGetAllTasks(TodoList* obj, int userId, int* returnSize) {
    static Task userTasks[MAX_TASKS];
    int count = 0;
    
    for (int i = 0; i < obj->taskCount; i++) {
        if (obj->tasks[i].userId == userId && !obj->tasks[i].completed) {
            userTasks[count++] = obj->tasks[i];
        }
    }
    
    qsort(userTasks, count, sizeof(Task), compareByDueDate);
    
    static char* result[MAX_TASKS];
    for (int i = 0; i < count; i++) {
        result[i] = userTasks[i].description;
    }
    
    *returnSize = count;
    return result;
}

bool hasTag(Task* task, char* tag) {
    for (int i = 0; i < task->tagCount; i++) {
        if (strcmp(task->tags[i], tag) == 0) {
            return true;
        }
    }
    return false;
}

char** todoListGetTasksForTag(TodoList* obj, int userId, char* tag, int* returnSize) {
    static Task taggedTasks[MAX_TASKS];
    int count = 0;
    
    for (int i = 0; i < obj->taskCount; i++) {
        if (obj->tasks[i].userId == userId && !obj->tasks[i].completed && 
            hasTag(&obj->tasks[i], tag)) {
            taggedTasks[count++] = obj->tasks[i];
        }
    }
    
    qsort(taggedTasks, count, sizeof(Task), compareByDueDate);
    
    static char* result[MAX_TASKS];
    for (int i = 0; i < count; i++) {
        result[i] = taggedTasks[i].description;
    }
    
    *returnSize = count;
    return result;
}

void todoListCompleteTask(TodoList* obj, int userId, int taskId) {
    for (int i = 0; i < obj->taskCount; i++) {
        if (obj->tasks[i].id == taskId && obj->tasks[i].userId == userId && 
            !obj->tasks[i].completed) {
            obj->tasks[i].completed = true;
            break;
        }
    }
}

void todoListFree(TodoList* obj) {
    free(obj);
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Every operation requires scanning all n tasks in the system

✓ Linear Growth

Space Complexity

O(n)

Only stores the tasks themselves without additional indexing

⚡ Linearithmic Space

42.8K Views

High Frequency

~15 min Avg. Time

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