Enhancing a Voting System Using PHP | CodeSignal Learn

Enhancing a Voting System Using PHP | CodeSignal Learn

Let's jump into the PHP code and begin the implementation of our starter task. Here, we use PHP's arrays as the core of our design. Associative arrays allow us to have dynamic structures keyed based on candidate IDs and voter IDs, which will greatly simplify our design.

PHP

class VotingSystem {
    private array $candidates;  // Stores candidate_id as key and votes as value
    private array $voters;  // Tracks each voter's voting history

    public function __construct() {
        $this->candidates = [];  // Initialize candidates array
        $this->voters = [];  // Initialize voters array
    }

    public function registerCandidate(string $candidateId): bool {
        if (array_key_exists($candidateId, $this->candidates)) {
            return false;  // Candidate is already registered
        }
        $this->candidates[$candidateId] = 0;  // Initialize candidates with 0 votes
        return true;
    }

    public function vote(int $timestamp, string $voterId, string $candidateId): bool {
        if (!array_key_exists($candidateId, $this->candidates)) {
            return false;  // Return false if candidate is not registered
        }
        if (!isset($this->voters[$voterId])) {
            $this->voters[$voterId] = new VotingHistory();
        }
        $voterHistory = $this->voters[$voterId];
        $voterHistory->votes[] = $candidateId;  // Record the vote
        $voterHistory->timestamps[] = $timestamp;  // Record the time of the vote
        $this->candidates[$candidateId]++;  // Increment vote count for the candidate
        return true;
    }

    public function getVotes(string $candidateId): ?int {
        return $this->candidates[$candidateId] ?? null;  // Retrieve vote count for a candidate or null if not found
    }

    public function topNCandidates(int $n): array {
        arsort($this->candidates);
        return array_slice(array_keys($this->candidates), 0, $n);  // Return top n candidates based on votes
    }
}

class VotingHistory {
    public array $votes;
    public array $timestamps;

    public function __construct() {
        $this->votes = [];
        $this->timestamps = [];
    }
}

We proceed to enhance our existing VotingSystem class to accommodate the new functionalities.

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

PHP

private ?int $blockTime = null;

public function getVotingHistory(string $voterId): ?array {
    if (!isset($this->voters[$voterId])) {
        return null;
    }
    $voterHistory = $this->voters[$voterId];
    $votingHistory = [];

    foreach ($voterHistory->votes as $candidateId) {
        if (!isset($votingHistory[$candidateId])) {
            $votingHistory[$candidateId] = 0;
        }
        $votingHistory[$candidateId]++;
    }
    return $votingHistory;  // Returns an array with each candidate voted for and the number of times they were voted for
}

public function blockVoterRegistration(int $timestamp): bool {
    $this->blockTime = $timestamp;  // Records the timestamp after which no registration is allowed
    return true;
}

With the introduction of the blockVoterRegistration functionality, we must revisit our vote function to ensure it respects the new rules set by this feature. Specifically, we need to ensure that no votes are cast after the voter registration has been blocked. This is critical in maintaining the integrity of the voting system, especially in scenarios where registration deadlines are enforced. Here's how we modify the vote function to incorporate this change:

PHP

public function vote(int $timestamp, string $voterId, string $candidateId): bool {
    // Check if blockTime is set and if the vote attempt is after the block timestamp
    if ($this->blockTime !== null && $timestamp >= $this->blockTime) {
        return false;  // Vote attempt is blocked due to the registration freeze
    }
    
    if (!array_key_exists($candidateId, $this->candidates)) {
        return false;  // Return false if the candidate is not registered
    }
    
    if (!isset($this->voters[$voterId])) {
        $this->voters[$voterId] = new VotingHistory();
    }
    
    $voterHistory = $this->voters[$voterId];
    $voterHistory->votes[] = $candidateId;  // Record the vote
    $voterHistory->timestamps[] = $timestamp;  // Record the time of the vote
    $this->candidates[$candidateId]++;  // Increment vote count for the candidate
    
    return true;
}

This update ensures that our voting system behaves as expected, even with the new functionality to block further voter registrations beyond a certain timestamp. It's a perfect demonstration of how new features can necessitate revisits and revisions to existing code to enhance functionality while ensuring backward compatibility.

The changeVote method allows voters to change their vote, adhering to specific rules. Here's a step-by-step explanation of implementing this functionality:

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 time frame 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.

PHP

public function changeVote(int $timestamp, string $voterId, string $oldCandidateId, string $newCandidateId): bool {
    // Verify existence in the voting system
    if (!isset($this->candidates[$oldCandidateId]) || !isset($this->candidates[$newCandidateId])) {
        return false;
    }

    // Check if the voter_id is valid and has previously voted
    if (!isset($this->voters[$voterId]) || empty($this->voters[$voterId]->votes)) {
        return false;  // Voter is either not registered or has not voted yet
    }

    $voterHistory = $this->voters[$voterId];
    // Confirm voter has voted for the old candidate
    $lastVoteIndex = array_search($oldCandidateId, array_reverse($voterHistory->votes, true));
    if ($lastVoteIndex === false) {
        return false;
    }

    // Ensure the operation is within the permitted timeframe
    if ($timestamp - $voterHistory->timestamps[$lastVoteIndex] > 86400) {  // 24 hours in seconds
        return false;
    }

    // Perform the vote change
    // Remove the old vote
    unset($voterHistory->votes[$lastVoteIndex]);
    unset($voterHistory->timestamps[$lastVoteIndex]);
    
    // Append the new vote
    $voterHistory->votes[] = $newCandidateId;
    $voterHistory->timestamps[] = $timestamp;

    // Update candidates' vote counts
    $this->candidates[$oldCandidateId]--;
    $this->candidates[$newCandidateId]++;

    return true;
}

Note: In the implementation of the changeVote method, we don't use blockTime because blockTime is intended to halt new voter registrations and votes after the specified timestamp. However, the changeVote method is focused on changing an existing vote. Since it's assumed that the voter has already registered and cast their vote before the blockTime, the focus here is on validating the vote change within the 24-hour window, irrespective of blockTime. Therefore, blockTime does not need to be considered in this context where changes to existing votes are allowed.