Welcome back to another exciting session where we 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.
In our initial task, we created a simple voting system in Kotlin with a set of basic functionalities:
fun registerCandidate(candidateId: String): Boolean: This function is used for adding new candidates to our system.fun vote(timestamp: Long, voterId: String, candidateId: String): Boolean: This function facilitates users casting their votes. Each vote is given a timestamp.fun getVotes(candidateId: String): Int?: This function retrieves the total number of votes for a given candidate.fun topNCandidates(n: Int): List<String>: We also want to add a leaderboard functionality to our system. This function returns the topncandidates sorted by the number of votes.
Let's jump into the Kotlin code and begin the implementation of our starter task. Here, we use Kotlin's mutableMapOf() and mutableListOf() as the core of our design. These collections allow us to have dynamic lists keyed based on candidate IDs and voter IDs, which will greatly simplify our design.
Kotlin1class VotingSystem { 2 private val candidates: MutableMap<String, Int> = mutableMapOf() // Stores candidate_id as key and votes as value 3 private val voters: MutableMap<String, VotingHistory> = mutableMapOf() // Tracks each voter's voting history 4 5 fun registerCandidate(candidateId: String): Boolean { 6 if (candidates.containsKey(candidateId)) { 7 return false // Candidate is already registered 8 } 9 candidates[candidateId] = 0 // Initialize candidates with 0 votes 10 return true 11 } 12 13 fun vote(timestamp: Long, voterId: String, candidateId: String): Boolean { 14 if (!candidates.containsKey(candidateId)) { 15 return false // Return false if candidate is not registered 16 } 17 val voterHistory = voters.computeIfAbsent(voterId) { VotingHistory() } 18 voterHistory.votes.add(candidateId) // Record the vote 19 voterHistory.timestamps.add(timestamp) // Record the time of the vote 20 candidates[candidateId] = candidates[candidateId]!! + 1 // Increment vote count for the candidate 21 return true 22 } 23 24 fun getVotes(candidateId: String): Int? { 25 return candidates[candidateId] // Retrieve vote count for a candidate or null if not found 26 } 27 28 fun topNCandidates(n: Int): List<String> { 29 return candidates.entries 30 .sortedByDescending { it.value } 31 .take(n) 32 .map { it.key } // Return top n candidates based on votes 33 } 34 35 private class VotingHistory { 36 val votes: MutableList<String> = mutableListOf() 37 val timestamps: MutableList<Long> = mutableListOf() 38 } 39}
Now that we have a basic voting system, our goal is to enhance this system with additional functionalities:
fun getVotingHistory(voterId: String): Map<String, Int>?: Provides a detailed voting history for a specified voter, returning a map with candidates and the number of votes they received from the voter. Returnsnullif the voter ID does not exist.fun blockVoterRegistration(timestamp: Long): Boolean: Implements a mechanism to halt any new voter registrations past a specified timestamp, effectively freezing the voter list as of that moment.fun changeVote(timestamp: Long, voterId: String, oldCandidateId: String, newCandidateId: String): Boolean: 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.
We proceed to enhance our existing VotingSystem class to accommodate the new functionalities.
First, let's incorporate the functions to get the voting history and to block further voter registrations:
Kotlin1private var blockTime: Long? = null // Time after which registrations are blocked 2 3fun getVotingHistory(voterId: String): Map<String, Int>? { 4 val voterHistory = voters[voterId] ?: return null 5 val votingHistory = mutableMapOf<String, Int>() 6 voterHistory.votes.forEach { candidateId -> 7 votingHistory[candidateId] = votingHistory.getOrDefault(candidateId, 0) + 1 8 } 9 return votingHistory // Returns a map with each candidate voted for and the number of times they were voted for 10} 11 12fun blockVoterRegistration(timestamp: Long): Boolean { 13 this.blockTime = timestamp // Records the timestamp after which no registration is allowed 14 return true 15}
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 method to incorporate this change:
Kotlin1fun vote(timestamp: Long, voterId: String, candidateId: String): Boolean { 2 // Check if blockTime is set and if the vote attempt is after the block timestamp 3 if (blockTime != null && timestamp >= blockTime!!) { 4 return false // Vote attempt is blocked due to the registration freeze 5 } 6 7 if (!candidates.containsKey(candidateId)) { 8 return false // Return false if the candidate is not registered 9 } 10 11 val voterHistory = voters.computeIfAbsent(voterId) { VotingHistory() } 12 voterHistory.votes.add(candidateId) // Record the vote 13 voterHistory.timestamps.add(timestamp) // Record the time of the vote 14 candidates[candidateId] = candidates[candidateId]!! + 1 // Increment vote count for the candidate 15 16 return true 17}
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 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.
Kotlin1fun changeVote(timestamp: Long, voterId: String, oldCandidateId: String, newCandidateId: String): Boolean { 2 // Verify existence in the voting system 3 if (!candidates.containsKey(oldCandidateId) || !candidates.containsKey(newCandidateId)) { 4 return false 5 } 6 7 val voterHistory = voters[voterId] ?: return false 8 // Confirm voter has voted for the old candidate 9 if (!voterHistory.votes.contains(oldCandidateId)) { 10 return false 11 } 12 13 // Ensure the operation is within the permitted timeframe 14 val lastVoteIndex = voterHistory.votes.lastIndexOf(oldCandidateId) 15 val lastVoteTime = voterHistory.timestamps[lastVoteIndex] 16 if (timestamp - lastVoteTime > 86400) { // 24 hours in seconds 17 return false 18 } 19 20 // Perform the vote change 21 // Remove the old vote 22 voterHistory.votes.removeAt(lastVoteIndex) 23 voterHistory.timestamps.removeAt(lastVoteIndex) 24 25 // Append the new vote 26 voterHistory.votes.add(newCandidateId) 27 voterHistory.timestamps.add(timestamp) 28 29 // Update candidates' vote counts 30 candidates[oldCandidateId] = candidates[oldCandidateId]!! - 1 31 candidates[newCandidateId] = candidates[newCandidateId]!! + 1 32 33 return true 34}
Congratulations! You've successfully enhanced the voting system by adding functionalities to view voting history, block new candidate registrations, and, most importantly, enable vote changes under specific conditions. Each of these features was developed with careful consideration to maintain the integrity and backward compatibility of the system. Continue exploring with practice sessions and further experimentation to refine your skills in developing complex, functionality-rich applications. Happy coding!