You can only
guarantee two.

// Simplified Raft-style consensus check.
// Used by etcd, CockroachDB, and similar CP systems.
#[derive(Debug, PartialEq)]
enum ConsensusResult {
    Committed(String),    // majority agreed
    Pending,              // still gathering votes
    Rejected,             // could not reach quorum
}

fn check_consensus(
    votes: &[Option<String>],
    quorum: usize,
) -> ConsensusResult {
    let total = votes.len();
    let agreements: Vec<&String> = votes.iter().flatten().collect();

    if agreements.len() >= quorum {
        // Majority agreed on a value: this is how
        // CP systems commit a write.
        ConsensusResult::Committed(agreements[0].clone())
    } else if total - agreements.len() > total - quorum {
        // Too many nodes unreachable to ever reach quorum.
        // CP: reject rather than risk inconsistency.
        ConsensusResult::Rejected
    } else {
        ConsensusResult::Pending
    }
}

fn main() {
    // 5 nodes, need 3 for quorum.
    let votes = vec![
        Some("value_42".to_string()),
        Some("value_42".to_string()),
        Some("value_42".to_string()),
        None, // node unreachable
        None, // node unreachable
    ];

    match check_consensus(&votes, 3) {
        ConsensusResult::Committed(v) => println!("Committed: {}", v),
        ConsensusResult::Rejected => println!("Rejected: partition detected"),
        ConsensusResult::Pending => println!("Waiting for quorum..."),
    }
    // Output: Committed: value_42
}

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

typedef enum { COMMITTED, PENDING, REJECTED } ConsensusResult;

ConsensusResult check_consensus(
    const char** votes, // NULL = unreachable node
    size_t total,
    size_t quorum,
    char* out_value,
    size_t out_size
) {
    size_t agreements = 0;
    const char* agreed_value = NULL;

    for (size_t i = 0; i < total; i++) {
        if (votes[i] != NULL) {
            if (!agreed_value) agreed_value = votes[i];
            if (strcmp(votes[i], agreed_value) == 0) agreements++;
        }
    }

    if (agreements >= quorum) {
        if (out_value && agreed_value)
            strncpy(out_value, agreed_value, out_size);
        return COMMITTED;
    }

    size_t unreachable = total - agreements;
    if (unreachable > total - quorum) return REJECTED;
    return PENDING;
}

int main(void) {
    const char* votes[] = { "value_42", "value_42", "value_42", NULL, NULL };
    char result[64];
    ConsensusResult r = check_consensus(votes, 5, 3, result, sizeof(result));
    if (r == COMMITTED)      printf("Committed: %s\n", result);
    else if (r == REJECTED)  printf("Rejected: partition detected\n");
    else                     printf("Pending: waiting for quorum\n");
    return 0;
}