Enhancing Voting Systems with Advanced C++ Features

Introduction

Welcome back to a fascinating session where we will learn about enhancing existing functionality without causing regressions. Our scenario today involves designing a voting system . We'll start with the basic implementation of the voting system and gradually introduce additional elements of complexity.

Initial Solution Development

Let's start by building our basic voting system using C++ standard library features. We will utilize std::map to maintain our data, which allows us to seamlessly store and retrieve information about candidates and voters. This map acts as the backbone of our system for the dynamic association of keys to values. C++#include <iostream> #include <map> #include <vector> #include <algorithm> class VotingSystem { private: std::map<std::string, int> candidates_; // Stores candidate_id as key and votes as value std::map<std::string, std::pair<std::vector<std::string>, std::vector<int>>> voters_; // Tracks each voter's voting history public: bool register_candidate(const std::string& candidate_id) { // Add a new candidate to the system if not already present if (candidates_.count(candidate_id)) { return false; // Candidate is already registered } candidates_[candidate_id] = 0; // Initialize candidate with 0 votes return true; } bool vote(int timestamp, const std::string& voter_id, const std::string& candidate_id) { // Cast a vote if the candidate is registered if (!candidates_.count(candidate_id)) { return false; // Candidate not registered } voters_[voter_id].first.push_back(candidate_id); // Record the vote voters_[voter_id].second.push_back(timestamp); // Record the time of the vote candidates_[candidate_id]++; // Increment vote count for the candidate return true; } int get_votes(const std::string& candidate_id) const { // Retrieve vote count for a candidate or return -1 if not found auto it = candidates_.find(candidate_id); if (it != candidates_.end()) { return it->second; } return -1; } };

Introduce New Methods

Now that we have a basic voting system, our goal is to enhance this system with additional functionalities: get_voting_history(const std::string& voter_id) : Provides a detailed voting history for a specified voter, returning a map that shows how many times the voter has voted for each candidate. block_voter_registration(int timestamp) : Implements a mechanism to halt any new voter registrations past a specified timestamp, effectively freezing the voter list as of that moment. change_vote(int timestamp, const std::string& voter_id, const std::string& old_candidate_id, const std::string& new_candidate_id) : Enables voters to change their vote from one candidate to another, given the change is made within a 24-hour window from their last vote, ensuring both the old and new candidates are registered, and that the voter initially voted for the old candidate.

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Implementing New Methods

We proceed to enhance our existing VotingSystem class to accommodate the new functionalities, utilizing C++ features efficiently.

First, let's incorporate the methods to get the voting history and to block further voter registrations:

C++

#include <optional>

class VotingSystem {
    // Existing code...
    int block_time_ = -1;

public:
    std::optional<std::map<std::string, int>> get_voting_history(const std::string& voter_id) const {
        if (voters_.count(voter_id) == 0) {
            return std::nullopt; // Voter ID does not exist
        }
        std::map<std::string, int> voting_history;
        for (const auto& candidate_id : voters_.at(voter_id).first) {
            voting_history[candidate_id]++;
        }
        return voting_history;
    }

    bool block_voter_registration(int timestamp) {
        block_time_ = timestamp; // Set the block time
        return true;
    }
};

#include <optional>

class VotingSystem {
    // Existing code...
    int block_time_ = -1;

public:
    std::optional<std::map<std::string, int>> get_voting_history(const std::string& voter_id) const {
        if (voters_.count(voter_id) == 0) {
            return std::nullopt; // Voter ID does not exist
        }
        std::map<std::string, int> voting_history;
        for (const auto& candidate_id : voters_.at(voter_id).first) {
            voting_history[candidate_id]++;
        }
        return voting_history;
    }

    bool block_voter_registration(int timestamp) {
        block_time_ = timestamp; // Set the block time
        return true;
    }
};

The get_voting_history(const std::string& voter_id) method fetches a detailed voting history for a given voter. It returns an optional map, where the keys are candidate IDs and the values represent how many times the voter has voted for each candidate. If the voter ID does not exist, it returns std::nullopt.

The block_voter_registration(int timestamp) method is used to prevent any further voter registrations after a specified timestamp. It effectively freezes the voter list as of the given timestamp, reflecting a critical system state change that needs to be implemented in a versatile and non-intrusive manner.

Implementing `change_vote` Method

The change_vote method allows voters to change their vote, adhering to specific rules as detailed below:

Verify Candidate and Voter Validity: Check if both the old and new candidate IDs exist in the system, and verify that the voter has previously voted for the old candidate.
Timestamp Constraints: Ensure that the voter is trying to change their vote within an allowable timeframe after their initial vote.
Update Votes: If all conditions are met, subtract one vote from the old candidate, add one vote to the new candidate, and update the voter's voting record.

C++

bool change_vote(int timestamp, const std::string& voter_id, const std::string& old_candidate_id, const std::string& new_candidate_id) {
    if (!candidates_.count(old_candidate_id) || !candidates_.count(new_candidate_id)) {
        return false; // Invalid candidate IDs
    }
    if (!voters_.count(voter_id) || std::find(voters_[voter_id].first.begin(), voters_[voter_id].first.end(), old_candidate_id) == voters_[voter_id].first.end()) {
        return false; // Voter hasn't voted for the old candidate
    }

    auto& votes = voters_[voter_id].first;
    auto& timestamps = voters_[voter_id].second;
    auto it = std::find(votes.rbegin(), votes.rend(), old_candidate_id);

    if (it == votes.rend() || (timestamp - timestamps[std::distance(votes.begin(), it.base()) - 1]) > 86400) {
        return false; // Vote change not within the 24-hour window
    }

    size_t index = std::distance(votes.begin(), it.base() - 1);
    votes[index] = new_candidate_id; // Change the vote
    timestamps[index] = timestamp; // Update timestamp

    candidates_[old_candidate_id]--; // Decrease old candidate's vote count
    candidates_[new_candidate_id]++; // Increase new candidate's vote count

    return true;
}

bool change_vote(int timestamp, const std::string& voter_id, const std::string& old_candidate_id, const std::string& new_candidate_id) {
    if (!candidates_.count(old_candidate_id) || !candidates_.count(new_candidate_id)) {
        return false; // Invalid candidate IDs
    }
    if (!voters_.count(voter_id) || std::find(voters_[voter_id].first.begin(), voters_[voter_id].first.end(), old_candidate_id) == voters_[voter_id].first.end()) {
        return false; // Voter hasn't voted for the old candidate
    }

    auto& votes = voters_[voter_id].first;
    auto& timestamps = voters_[voter_id].second;
    auto it = std::find(votes.rbegin(), votes.rend(), old_candidate_id);

    if (it == votes.rend() || (timestamp - timestamps[std::distance(votes.begin(), it.base()) - 1]) > 86400) {
        return false; // Vote change not within the 24-hour window
    }

    size_t index = std::distance(votes.begin(), it.base() - 1);
    votes[index] = new_candidate_id; // Change the vote
    timestamps[index] = timestamp; // Update timestamp

    candidates_[old_candidate_id]--; // Decrease old candidate's vote count
    candidates_[new_candidate_id]++; // Increase new candidate's vote count

    return true;
}