TypeScript
Copy to clipboard
1class VotingSystem {
2  private candidates: Map<string, number>; // Stores candidateId as key and votes as value
3  private voters: Map<string, { votes: string[]; timestamps: number[] }>; // Tracks each voter's voting history
4  private blockTime?: number; // Optional timestamp for blocking voter registration
5
6  constructor() {
7    this.candidates = new Map<string, number>();
8    this.voters = new Map<string, { votes: string[]; timestamps: number[] }>();
9  }
10
11  registerCandidate(candidateId: string): boolean {
12    if (this.candidates.has(candidateId)) {
13      return false; // Candidate is already registered
14    }
15    this.candidates.set(candidateId, 0); // Initialize candidates with 0 votes
16    return true;
17  }
18
19  vote(timestamp: number, voterId: string, candidateId: string): boolean {
20    // Check if blockTime is set and if the vote attempt is after the block timestamp
21    if (this.blockTime && timestamp >= this.blockTime) {
22      return false; // Vote attempt is blocked due to the registration freeze
23    }
24
25    if (!this.candidates.has(candidateId)) {
26      return false; // Returns false if candidate is not registered
27    }
28
29    if (!this.voters.has(voterId)) {
30      this.voters.set(voterId, { votes: [], timestamps: [] });
31    }
32
33    const voterData = this.voters.get(voterId)!;
34    voterData.votes.push(candidateId); // Record the vote
35    voterData.timestamps.push(timestamp); // Record the time of the vote
36    this.candidates.set(candidateId, this.candidates.get(candidateId)! + 1); // Increment vote count for the candidate
37    return true;
38  }
39
40  getVotes(candidateId: string): number | null {
41    return this.candidates.get(candidateId) || null; // Retrieve vote count for a candidate, or null if not found
42  }
43
44  topNCandidates(n: number): string[] {
45    return Array.from(this.candidates.keys())
46      .sort((a, b) => this.candidates.get(b)! - this.candidates.get(a)!)
47      .slice(0, n); // Return top `n` candidates based on votes
48  }
49}

TypeScript
Copy to clipboard
1class VotingSystem {
2  // existing fields and constructor here...
3
4  getVotingHistory(voterId: string): Record<string, number> | null {
5    if (!this.voters.has(voterId)) {
6      return null;
7    }
8    const voterData = this.voters.get(voterId)!;
9    const votingHistory: Record<string, number> = {};
10    voterData.votes.forEach((candidateId) => {
11      if (!votingHistory[candidateId]) {
12        votingHistory[candidateId] = 0;
13      }
14      votingHistory[candidateId]++;
15    });
16    return votingHistory; // Returns an object with each candidate voted for, and the number of times they were voted for
17  }
18
19  blockVoterRegistration(timestamp: number): boolean {
20    this.blockTime = timestamp; // Records the timestamp after which no registration is allowed
21    return true;
22  }
23}

TypeScript
Copy to clipboard
1class VotingSystem {
2  // existing fields, constructor, and methods here…
3
4  vote(timestamp: number, voterId: string, candidateId: string): boolean {
5    // Check if blockTime is set and if the vote attempt is after the block timestamp
6    if (this.blockTime && timestamp >= this.blockTime) {
7      return false; // Vote attempt is blocked due to the registration freeze
8    }
9
10    if (!this.candidates.has(candidateId)) {
11      return false; // Returns false if candidate is not registered
12    }
13
14    if (!this.voters.has(voterId)) {
15      this.voters.set(voterId, { votes: [], timestamps: [] });
16    }
17
18    const voterData = this.voters.get(voterId)!;
19    voterData.votes.push(candidateId); // Record the vote
20    voterData.timestamps.push(timestamp); // Record the time of the vote
21    this.candidates.set(candidateId, this.candidates.get(candidateId)! + 1); // Increment vote count for the candidate
22    return true;
23  }
24}

TypeScript
Copy to clipboard
1class VotingSystem {
2  // existing fields, constructor, and methods here…
3
4  changeVote(timestamp: number, voterId: string, oldCandidateId: string, newCandidateId: string): boolean {
5    // Verify existence in the voting system
6    if (!this.candidates.has(oldCandidateId) || !this.candidates.has(newCandidateId)) {
7      return false;
8    }
9
10    // Check if the voterId is valid and has previously voted
11    if (!this.voters.has(voterId) || !this.voters.get(voterId)!.votes.length) {
12      return false; // Voter is either not registered or has not voted yet
13    }
14
15    const voterData = this.voters.get(voterId)!; 
16
17    // Confirm the voter has voted for the old candidate
18    const lastVoteIndex = voterData.votes.lastIndexOf(oldCandidateId);
19    if (lastVoteIndex === -1) {
20      return false;
21    }
22
23    // Ensure the operation is within the permitted timeframe
24    if (timestamp - voterData.timestamps[lastVoteIndex] > 86400) { // 24 hours in seconds
25      return false;
26    }
27
28    // Perform the vote change
29    voterData.votes.splice(lastVoteIndex, 1); // Remove the old vote
30    voterData.timestamps.splice(lastVoteIndex, 1); // Remove the corresponding timestamp
31    voterData.votes.push(newCandidateId); // Append the new vote
32    voterData.timestamps.push(timestamp); // Append the new timestamp
33
34    // Update candidates' vote counts
35    this.candidates.set(oldCandidateId, this.candidates.get(oldCandidateId)! - 1);
36    this.candidates.set(newCandidateId, this.candidates.get(newCandidateId)! + 1);
37
38    return true;
39  }
40}