Raft Consensus Simulator - Problem

Implement a Raft consensus protocol simulator that handles the three core components of the algorithm:

1. Leader Election: When nodes start or detect leader failure, they transition through states (Follower → Candidate → Leader) using randomized timeouts and majority voting.

2. Log Replication: The leader receives client requests, appends entries to its log, and replicates them to followers using AppendEntries RPCs with consistency checks.

3. Commit Handling: Once a majority of nodes have replicated an entry, the leader commits it and notifies followers to apply it to their state machines.

Your simulator should process a sequence of events ('election', 'append', 'commit') and return the final state of all nodes including their roles, terms, logs, and commit indices.

Input & Output

Example 1 — Basic Election and Log Replication

$ Input: numNodes = 3, events = [{"type":"election","nodeId":0},{"type":"append","entry":"cmd1"},{"type":"commit","index":0}]

› Output: [{"id":0,"state":"leader","term":1,"log":["cmd1"],"commitIndex":0},{"id":1,"state":"follower","term":1,"log":["cmd1"],"commitIndex":0},{"id":2,"state":"follower","term":1,"log":["cmd1"],"commitIndex":0}]

💡 Note: Node 0 becomes leader, appends entry 'cmd1', replicates to all nodes, then commits when majority (all 3) have the entry.

Example 2 — Leadership Change

$ Input: numNodes = 3, events = [{"type":"election","nodeId":1},{"type":"append","entry":"cmd2"},{"type":"election","nodeId":2}]

› Output: [{"id":0,"state":"follower","term":2,"log":["cmd2"],"commitIndex":-1},{"id":1,"state":"follower","term":2,"log":["cmd2"],"commitIndex":-1},{"id":2,"state":"leader","term":2,"log":["cmd2"],"commitIndex":-1}]

💡 Note: Node 1 becomes leader and adds entry, then Node 2 takes over leadership in a new term. All nodes maintain the log but entry isn't committed.

Example 3 — Multiple Operations

$ Input: numNodes = 5, events = [{"type":"election","nodeId":2},{"type":"append","entry":"op1"},{"type":"append","entry":"op2"},{"type":"commit","index":0},{"type":"commit","index":1}]

› Output: [{"id":0,"state":"follower","term":1,"log":["op1","op2"],"commitIndex":1},{"id":1,"state":"follower","term":1,"log":["op1","op2"],"commitIndex":1},{"id":2,"state":"leader","term":1,"log":["op1","op2"],"commitIndex":1},{"id":3,"state":"follower","term":1,"log":["op1","op2"],"commitIndex":1},{"id":4,"state":"follower","term":1,"log":["op1","op2"],"commitIndex":1}]

💡 Note: Node 2 becomes leader, adds two operations, and both get committed since all 5 nodes replicate them (majority achieved).

Constraints

1 ≤ numNodes ≤ 10
1 ≤ events.length ≤ 50
Event types: 'election', 'append', 'commit'
Entry strings have length ≤ 20

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 10 f Meta 8

The key insight is implementing a proper state machine that follows Raft consensus protocol with leader election, log replication, and majority-based commits. Best approach uses complete protocol implementation with proper term management and consistency checks. Time: O(E × N), Space: O(N × L)

Common Approaches

✓ Proper Raft Protocol Implementation

⏱️ Time: O(E × N) Space: O(N × L)

Complete implementation following Raft specification with proper state transitions, term management, log replication with consistency checks, and majority-based commit decisions.

Simple State Tracking

⏱️ Time: O(E) Space: O(N + L)

Implement a naive version that processes events sequentially without proper Raft state transitions, consensus checks, or failure handling mechanisms.

Proper Raft Protocol Implementation — Algorithm Steps

Initialize nodes with Raft state machines
Handle elections with term increments and voting
Replicate logs with consistency guarantees
Commit entries only after majority replication
Return comprehensive node states

Visualization

Tap to expand

Step-by-Step Walkthrough

Election Process

Candidate requests votes and becomes leader

Log Replication

Leader replicates entries to followers

Majority Commit

Commit only after majority has entry

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <cjson/cJSON.h>

typedef struct {
    int id;
    char state[20];
    int term;
    char log[100][100];
    int logSize;
    int commitIndex;
    int lastApplied;
    int votedFor;
    int* nextIndex;
    int* matchIndex;
} Node;

cJSON* solution(int numNodes, cJSON* events) {
    Node* nodes = malloc(numNodes * sizeof(Node));
    
    for (int i = 0; i < numNodes; i++) {
        nodes[i].id = i;
        strcpy(nodes[i].state, "follower");
        nodes[i].term = 0;
        nodes[i].logSize = 0;
        nodes[i].commitIndex = -1;
        nodes[i].lastApplied = -1;
        nodes[i].votedFor = -1;
        nodes[i].nextIndex = calloc(numNodes, sizeof(int));
        nodes[i].matchIndex = malloc(numNodes * sizeof(int));
        for (int j = 0; j < numNodes; j++) {
            nodes[i].matchIndex[j] = -1;
        }
    }
    
    int currentTerm = 0;
    int leader = -1;
    
    cJSON* event = NULL;
    cJSON_ArrayForEach(event, events) {
        cJSON* type = cJSON_GetObjectItem(event, "type");
        
        if (strcmp(type->valuestring, "election") == 0) {
            cJSON* nodeId = cJSON_GetObjectItem(event, "nodeId");
            int candidateId = nodeId->valueint;
            currentTerm++;
            
            Node* candidate = &nodes[candidateId];
            strcpy(candidate->state, "candidate");
            candidate->term = currentTerm;
            candidate->votedFor = candidateId;
            
            int votes = 1; // Vote for self
            for (int i = 0; i < numNodes; i++) {
                if (i != candidateId) {
                    Node* node = &nodes[i];
                    if (node->term < currentTerm) {
                        node->term = currentTerm;
                        node->votedFor = candidateId;
                        strcpy(node->state, "follower");
                        votes++;
                    }
                }
            }
            
            if (votes > numNodes / 2) {
                strcpy(candidate->state, "leader");
                leader = candidateId;
                for (int i = 0; i < numNodes; i++) {
                    candidate->nextIndex[i] = candidate->logSize;
                    candidate->matchIndex[i] = -1;
                }
            } else {
                strcpy(candidate->state, "follower");
            }
            
        } else if (strcmp(type->valuestring, "append") == 0) {
            if (leader != -1) {
                cJSON* entry = cJSON_GetObjectItem(event, "entry");
                Node* leaderNode = &nodes[leader];
                strcpy(leaderNode->log[leaderNode->logSize], entry->valuestring);
                leaderNode->logSize++;
                
                for (int i = 0; i < numNodes; i++) {
                    if (i != leader) {
                        Node* follower = &nodes[i];
                        if (follower->logSize < leaderNode->logSize) {
                            for (int j = 0; j < leaderNode->logSize; j++) {
                                strcpy(follower->log[j], leaderNode->log[j]);
                            }
                            follower->logSize = leaderNode->logSize;
                            follower->term = leaderNode->term;
                        }
                    }
                }
            }
            
        } else if (strcmp(type->valuestring, "commit") == 0) {
            if (leader != -1) {
                cJSON* index = cJSON_GetObjectItem(event, "index");
                int commitIdx = index->valueint;
                Node* leaderNode = &nodes[leader];
                
                if (commitIdx < leaderNode->logSize) {
                    int replicated = 1; // Leader has it
                    for (int i = 0; i < numNodes; i++) {
                        if (i != leader && commitIdx < nodes[i].logSize) {
                            replicated++;
                        }
                    }
                    
                    if (replicated > numNodes / 2) {
                        for (int i = 0; i < numNodes; i++) {
                            if (commitIdx < nodes[i].logSize) {
                                if (nodes[i].commitIndex < commitIdx) {
                                    nodes[i].commitIndex = commitIdx;
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    
    cJSON* result = cJSON_CreateArray();
    for (int i = 0; i < numNodes; i++) {
        cJSON* nodeObj = cJSON_CreateObject();
        cJSON_AddNumberToObject(nodeObj, "id", nodes[i].id);
        cJSON_AddStringToObject(nodeObj, "state", nodes[i].state);
        cJSON_AddNumberToObject(nodeObj, "term", nodes[i].term);
        
        cJSON* logArray = cJSON_CreateArray();
        for (int j = 0; j < nodes[i].logSize; j++) {
            cJSON_AddItemToArray(logArray, cJSON_CreateString(nodes[i].log[j]));
        }
        cJSON_AddItemToObject(nodeObj, "log", logArray);
        cJSON_AddNumberToObject(nodeObj, "commitIndex", nodes[i].commitIndex);
        
        cJSON_AddItemToArray(result, nodeObj);
        
        free(nodes[i].nextIndex);
        free(nodes[i].matchIndex);
    }
    
    free(nodes);
    return result;
}

int main() {
    int numNodes;
    scanf("%d", &numNodes);
    getchar();
    
    char eventsStr[10000];
    fgets(eventsStr, sizeof(eventsStr), stdin);
    eventsStr[strcspn(eventsStr, "\n")] = 0;
    
    cJSON* events = cJSON_Parse(eventsStr);
    cJSON* result = solution(numNodes, events);
    
    char* output = cJSON_Print(result);
    printf("%s\n", output);
    
    cJSON_Delete(events);
    cJSON_Delete(result);
    free(output);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(E × N)

Process E events, each potentially updating N nodes

✓ Linear Growth

Space Complexity

O(N × L)

Store N nodes with up to L log entries each

✓ Linear Space

8.9K Views

Medium Frequency

~45 min Avg. Time

234 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

Raft Consensus Simulator - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Proper Raft Protocol Implementation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler