Transitioning to TypeScript for Enhanced Voting System Design

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.

Starter Task Review

In our initial task, we create a simple voting system in TypeScript with a set of basic functionalities. Let's define the methods with TypeScript type annotations: registerCandidate(candidateId: string): boolean : This method is used for adding new candidates to our system. vote(timestamp: number, voterId: string, candidateId: string): boolean : This method is designed to facilitate users in casting their votes. Each vote is given a timestamp. getVotes(candidateId: string): number | null : This method retrieves the total number of votes for a given candidate. topNCandidates(n: number): string[] : We also want to add a leaderboard functionality to our system. This method returns the top n candidates sorted by the number of votes.

Initial Solution Development

Join the 1M+ learners on CodeSignal

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

TypeScript

class VotingSystem {
  private candidates: Map<string, number>; // Stores candidateId as key and votes as value
  private voters: Map<string, { votes: string[]; timestamps: number[] }>; // Tracks each voter's voting history
  private blockTime?: number; // Optional timestamp for blocking voter registration

  constructor() {
    this.candidates = new Map<string, number>();
    this.voters = new Map<string, { votes: string[]; timestamps: number[] }>();
  }

  registerCandidate(candidateId: string): boolean {
    if (this.candidates.has(candidateId)) {
      return false; // Candidate is already registered
    }
    this.candidates.set(candidateId, 0); // Initialize candidates with 0 votes
    return true;
  }

  vote(timestamp: number, voterId: string, candidateId: string): boolean {
    // Check if blockTime is set and if the vote attempt is after the block timestamp
    if (this.blockTime && timestamp >= this.blockTime) {
      return false; // Vote attempt is blocked due to the registration freeze
    }

    if (!this.candidates.has(candidateId)) {
      return false; // Returns false if candidate is not registered
    }

    if (!this.voters.has(voterId)) {
      this.voters.set(voterId, { votes: [], timestamps: [] });
    }

    const voterData = this.voters.get(voterId)!;
    voterData.votes.push(candidateId); // Record the vote
    voterData.timestamps.push(timestamp); // Record the time of the vote
    this.candidates.set(candidateId, this.candidates.get(candidateId)! + 1); // Increment vote count for the candidate
    return true;
  }

  getVotes(candidateId: string): number | null {
    return this.candidates.get(candidateId) || null; // Retrieve vote count for a candidate, or null if not found
  }

  topNCandidates(n: number): string[] {
    return Array.from(this.candidates.keys())
      .sort((a, b) => this.candidates.get(b)! - this.candidates.get(a)!)
      .slice(0, n); // Return top `n` candidates based on votes
  }
}

TypeScript

class VotingSystem {
  // existing fields and constructor here...

  getVotingHistory(voterId: string): Record<string, number> | null {
    if (!this.voters.has(voterId)) {
      return null;
    }
    const voterData = this.voters.get(voterId)!;
    const votingHistory: Record<string, number> = {};
    voterData.votes.forEach((candidateId) => {
      if (!votingHistory[candidateId]) {
        votingHistory[candidateId] = 0;
      }
      votingHistory[candidateId]++;
    });
    return votingHistory; // Returns an object with each candidate voted for, and the number of times they were voted for
  }

  blockVoterRegistration(timestamp: number): boolean {
    this.blockTime = timestamp; // Records the timestamp after which no registration is allowed
    return true;
  }
}

class VotingSystem {
  // existing fields and constructor here...

  getVotingHistory(voterId: string): Record<string, number> | null {
    if (!this.voters.has(voterId)) {
      return null;
    }
    const voterData = this.voters.get(voterId)!;
    const votingHistory: Record<string, number> = {};
    voterData.votes.forEach((candidateId) => {
      if (!votingHistory[candidateId]) {
        votingHistory[candidateId] = 0;
      }
      votingHistory[candidateId]++;
    });
    return votingHistory; // Returns an object with each candidate voted for, and the number of times they were voted for
  }

  blockVoterRegistration(timestamp: number): boolean {
    this.blockTime = timestamp; // Records the timestamp after which no registration is allowed
    return true;
  }
}

TypeScript

class VotingSystem {
  // existing fields, constructor, and methods here…

  vote(timestamp: number, voterId: string, candidateId: string): boolean {
    // Check if blockTime is set and if the vote attempt is after the block timestamp
    if (this.blockTime && timestamp >= this.blockTime) {
      return false; // Vote attempt is blocked due to the registration freeze
    }

    if (!this.candidates.has(candidateId)) {
      return false; // Returns false if candidate is not registered
    }

    if (!this.voters.has(voterId)) {
      this.voters.set(voterId, { votes: [], timestamps: [] });
    }

    const voterData = this.voters.get(voterId)!;
    voterData.votes.push(candidateId); // Record the vote
    voterData.timestamps.push(timestamp); // Record the time of the vote
    this.candidates.set(candidateId, this.candidates.get(candidateId)! + 1); // Increment vote count for the candidate
    return true;
  }
}

class VotingSystem {
  // existing fields, constructor, and methods here…

  vote(timestamp: number, voterId: string, candidateId: string): boolean {
    // Check if blockTime is set and if the vote attempt is after the block timestamp
    if (this.blockTime && timestamp >= this.blockTime) {
      return false; // Vote attempt is blocked due to the registration freeze
    }

    if (!this.candidates.has(candidateId)) {
      return false; // Returns false if candidate is not registered
    }

    if (!this.voters.has(voterId)) {
      this.voters.set(voterId, { votes: [], timestamps: [] });
    }

    const voterData = this.voters.get(voterId)!;
    voterData.votes.push(candidateId); // Record the vote
    voterData.timestamps.push(timestamp); // Record the time of the vote
    this.candidates.set(candidateId, this.candidates.get(candidateId)! + 1); // Increment vote count for the candidate
    return true;
  }
}

TypeScript

class VotingSystem {
  // existing fields, constructor, and methods here…

  changeVote(timestamp: number, voterId: string, oldCandidateId: string, newCandidateId: string): boolean {
    // Verify existence in the voting system
    if (!this.candidates.has(oldCandidateId) || !this.candidates.has(newCandidateId)) {
      return false;
    }

    // Check if the voterId is valid and has previously voted
    if (!this.voters.has(voterId) || !this.voters.get(voterId)!.votes.length) {
      return false; // Voter is either not registered or has not voted yet
    }

    const voterData = this.voters.get(voterId)!; 

    // Confirm the voter has voted for the old candidate
    const lastVoteIndex = voterData.votes.lastIndexOf(oldCandidateId);
    if (lastVoteIndex === -1) {
      return false;
    }

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

    // Perform the vote change
    voterData.votes.splice(lastVoteIndex, 1); // Remove the old vote
    voterData.timestamps.splice(lastVoteIndex, 1); // Remove the corresponding timestamp
    voterData.votes.push(newCandidateId); // Append the new vote
    voterData.timestamps.push(timestamp); // Append the new timestamp

    // Update candidates' vote counts
    this.candidates.set(oldCandidateId, this.candidates.get(oldCandidateId)! - 1);
    this.candidates.set(newCandidateId, this.candidates.get(newCandidateId)! + 1);

    return true;
  }
}

class VotingSystem {
  // existing fields, constructor, and methods here…

  changeVote(timestamp: number, voterId: string, oldCandidateId: string, newCandidateId: string): boolean {
    // Verify existence in the voting system
    if (!this.candidates.has(oldCandidateId) || !this.candidates.has(newCandidateId)) {
      return false;
    }

    // Check if the voterId is valid and has previously voted
    if (!this.voters.has(voterId) || !this.voters.get(voterId)!.votes.length) {
      return false; // Voter is either not registered or has not voted yet
    }

    const voterData = this.voters.get(voterId)!; 

    // Confirm the voter has voted for the old candidate
    const lastVoteIndex = voterData.votes.lastIndexOf(oldCandidateId);
    if (lastVoteIndex === -1) {
      return false;
    }

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

    // Perform the vote change
    voterData.votes.splice(lastVoteIndex, 1); // Remove the old vote
    voterData.timestamps.splice(lastVoteIndex, 1); // Remove the corresponding timestamp
    voterData.votes.push(newCandidateId); // Append the new vote
    voterData.timestamps.push(timestamp); // Append the new timestamp

    // Update candidates' vote counts
    this.candidates.set(oldCandidateId, this.candidates.get(oldCandidateId)! - 1);
    this.candidates.set(newCandidateId, this.candidates.get(newCandidateId)! + 1);

    return true;
  }
}

TypeScript

class VotingSystem {
  // existing fields and constructor here...

  getVotingHistory(voterId: string): Record<string, number> | null {
    if (!this.voters.has(voterId)) {
      return null;
    }
    const voterData = this.voters.get(voterId)!;
    const votingHistory: Record<string, number> = {};
    voterData.votes.forEach((candidateId) => {
      if (!votingHistory[candidateId]) {
        votingHistory[candidateId] = 0;
      }
      votingHistory[candidateId]++;
    });
    return votingHistory; // Returns an object with each candidate voted for, and the number of times they were voted for
  }

  blockVoterRegistration(timestamp: number): boolean {
    this.blockTime = timestamp; // Records the timestamp after which no registration is allowed
    return true;
  }
}

TypeScript

class VotingSystem {
  // existing fields, constructor, and methods here…

  vote(timestamp: number, voterId: string, candidateId: string): boolean {
    // Check if blockTime is set and if the vote attempt is after the block timestamp
    if (this.blockTime && timestamp >= this.blockTime) {
      return false; // Vote attempt is blocked due to the registration freeze
    }

    if (!this.candidates.has(candidateId)) {
      return false; // Returns false if candidate is not registered
    }

    if (!this.voters.has(voterId)) {
      this.voters.set(voterId, { votes: [], timestamps: [] });
    }

    const voterData = this.voters.get(voterId)!;
    voterData.votes.push(candidateId); // Record the vote
    voterData.timestamps.push(timestamp); // Record the time of the vote
    this.candidates.set(candidateId, this.candidates.get(candidateId)! + 1); // Increment vote count for the candidate
    return true;
  }
}

TypeScript

class VotingSystem {
  // existing fields, constructor, and methods here…

  changeVote(timestamp: number, voterId: string, oldCandidateId: string, newCandidateId: string): boolean {
    // Verify existence in the voting system
    if (!this.candidates.has(oldCandidateId) || !this.candidates.has(newCandidateId)) {
      return false;
    }

    // Check if the voterId is valid and has previously voted
    if (!this.voters.has(voterId) || !this.voters.get(voterId)!.votes.length) {
      return false; // Voter is either not registered or has not voted yet
    }

    const voterData = this.voters.get(voterId)!; 

    // Confirm the voter has voted for the old candidate
    const lastVoteIndex = voterData.votes.lastIndexOf(oldCandidateId);
    if (lastVoteIndex === -1) {
      return false;
    }

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

    // Perform the vote change
    voterData.votes.splice(lastVoteIndex, 1); // Remove the old vote
    voterData.timestamps.splice(lastVoteIndex, 1); // Remove the corresponding timestamp
    voterData.votes.push(newCandidateId); // Append the new vote
    voterData.timestamps.push(timestamp); // Append the new timestamp

    // Update candidates' vote counts
    this.candidates.set(oldCandidateId, this.candidates.get(oldCandidateId)! - 1);
    this.candidates.set(newCandidateId, this.candidates.get(newCandidateId)! + 1);

    return true;
  }
}

Introduction

Starter Task Review

Initial Solution Development

Join the 1M+ learners on CodeSignal

Introduce New Methods

Implementing New Methods

Updating the "vote" Method

Implementing "changeVote" Method

Conclusion