It's not who votes that counts; it's who counts the votes
Scala
Long live Alberto Arbusto!
import scala.io.Source
import java.util.concurrent.atomic.LongAdder

object Votes extends App {
  val votes = Source.stdin.getLines.toIndexedSeq
  val registeredCandidates = Seq(
    &quot;Alberto Arbusto&quot;,
    &quot;Juan Perez&quot;,
    &quot;Mickey Mouse&quot;,
    &quot;Jorge Sangre&quot;
  )

  val summaries = registeredCandidates map (Summary.apply(_, new LongAdder))
  
  var currentCandidate: String = _
  
  for (vote &lt;- votes.par) {
    currentCandidate = vote
    summaries.find(s =&gt; s.candidate == currentCandidate).map(_.total.increment)
  }
  
  for (summary &lt;- summaries.sortBy(-_.total.longValue)) {
    println(summary)
  }
}

case class Summary(candidate: String, total: LongAdder) {
  override def toString = s&quot;${total.longValue} ${candidate}&quot;
}

Alberto Arbusto will almost always come out slightly ahead of Jorge Sangre, provided enough votes are cast (~10,000). There's no need to tamper with the votes themselves.

 There's a race condition. And by putting Alberto Arbusto earlier in the list, we increase his chances of winning the race.

Side note: This code is loosely based on a &quot;custom&quot; connection pool that I encountered on a project. It took us weeks to figure out why the application was perpetually out of connections.