Consistent Hashing Demo - Problem

Implement a simple consistent hashing ring for distributing keys across N servers.

In consistent hashing, both servers and keys are mapped to positions on a circular hash ring using a hash function. Each key is assigned to the first server found when moving clockwise around the ring from the key's position.

Your task is to implement a ConsistentHashRing class with the following operations:

addServer(serverId) - Add a server to the ring
removeServer(serverId) - Remove a server from the ring
getServer(key) - Find which server should handle the given key

For this problem, use a simple hash function: hash(x) = (x * 31) % 1000000 where x is the numeric value of the string (sum of ASCII values).

Input & Output

Example 1 — Basic Operations

$ Input: operations = [["addServer","server1"],["addServer","server2"],["getServer","user123"],["removeServer","server1"],["getServer","user123"]]

› Output: ["server1","server2"]

💡 Note: Add server1 and server2. user123 maps to server1. After removing server1, user123 now maps to server2.

Example 2 — Wrap Around Ring

$ Input: operations = [["addServer","A"],["addServer","B"],["getServer","key999"]]

› Output: ["A"]

💡 Note: If key999 hashes beyond all servers, it wraps around to the first server on the ring.

Example 3 — No Servers Available

$ Input: operations = [["getServer","test"],["addServer","S1"],["getServer","test"]]

› Output: ["S1"]

💡 Note: First getServer returns null (no servers), after adding S1, test maps to S1.

Constraints

1 ≤ operations.length ≤ 1000
operations[i] is one of ["addServer", serverId], ["removeServer", serverId], or ["getServer", key]
serverId and key are strings of length 1-20 containing only letters and numbers
All server IDs are unique when added

Visualization

Tap to expand

Asked in

A Amazon 45 G Google 38 N Netflix 32 F Facebook 28

The key insight is to map both servers and keys to positions on a circular hash ring, then find the first server clockwise from each key. The optimal approach uses a sorted array with binary search for O(log n) lookups. Time: O(log n) per query, Space: O(n)

Common Approaches

✓ Linear Search Through All Servers

⏱️ Time: O(n) Space: O(n)

For each key lookup, calculate the key's hash position, then iterate through all servers to find the one with the smallest hash value that's greater than or equal to the key's position.

Sorted Array with Binary Search

⏱️ Time: O(log n) Space: O(n)

Maintain servers in a sorted array by their hash values. Use binary search to quickly find the next server clockwise from any key position.

Linear Search Through All Servers — Algorithm Steps

Hash the key to get its position on the ring
Iterate through all servers and hash each server ID
Find the server with minimum hash ≥ key hash (wrap around if needed)

Visualization

Tap to expand

Step-by-Step Walkthrough

Hash Key

Calculate hash position for the key

Check All Servers

Iterate through each server and hash its ID

Find Closest

Select server with minimum hash ≥ key hash

Code -

solution.c — C

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

char** solution(char*** operations, int operationsSize, int* returnSize) {
    char** results = malloc(1000 * sizeof(char*));
    *returnSize = 0;
    
    char servers[100][50];
    int serverCount = 0;
    
    int hashFunction(const char* key) {
        int asciiSum = 0;
        for (int i = 0; key[i]; i++) {
            asciiSum += (int)key[i];
        }
        return (asciiSum * 31) % 1000000;
    }
    
    void addServer(const char* serverId) {
        strcpy(servers[serverCount], serverId);
        serverCount++;
    }
    
    void removeServer(const char* serverId) {
        for (int i = 0; i < serverCount; i++) {
            if (strcmp(servers[i], serverId) == 0) {
                for (int j = i; j < serverCount - 1; j++) {
                    strcpy(servers[j], servers[j + 1]);
                }
                serverCount--;
                break;
            }
        }
    }
    
    char* getServer(const char* key) {
        if (serverCount == 0) return NULL;
        
        int keyHash = hashFunction(key);
        char* minServer = NULL;
        int minHash = 2000000;
        char* wrapServer = NULL;
        int wrapHash = 2000000;
        
        for (int i = 0; i < serverCount; i++) {
            int serverHash = hashFunction(servers[i]);
            if (serverHash >= keyHash && serverHash < minHash) {
                minHash = serverHash;
                minServer = servers[i];
            }
            if (serverHash < wrapHash) {
                wrapHash = serverHash;
                wrapServer = servers[i];
            }
        }
        
        return minServer ? minServer : wrapServer;
    }
    
    return results;
}

int main() {
    printf("[]\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each getServer operation checks all n servers linearly

✓ Linear Growth

Space Complexity

O(n)

Stores n servers in a simple list

⚡ Linearithmic Space

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

Consistent Hashing Demo - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Linear Search Through All Servers — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler