Is the use of Vote::Diebold allowed?

Here's my feeble entry:

use strict;
use warnings;

my @valid_candidates = ( 'Alice', 'Bob', 'Charlotte', 'David', 'Eve' )
+;
my %tally_for = map { lc($_) => [0] } @valid_candidates;

print "Welcome to the Die Bold 691549 Electrified Election Estimator\n
+";
print "Your candidates are:\n";
print map { "$_\n" } sort @valid_candidates;
print "Enter one name per line, end with EOF.\n";

while ( defined( my $candid_date = <> ) ) {
    chomp $candid_date;

    my $candidate;
    foreach ( @valid_candidates ) {
        last if lc $candid_date eq ( $candidate = lc $_ );
    }

    if ( exists $tally_for{ $candidate } ) {
        $tally_for{ $candidate }->[0]++;
    }
    else {
        warn "Write-in for $candid_date\n";
        $tally_for{ lc $candid_date }->[0]++;
    }
}

my @winner_first = reverse
                   sort { $tally_for{$a}->[0] <=> $tally_for{$b}->[0] 
+}
                   keys %tally_for;
foreach my $who ( @winner_first ) {
    printf "%10s : %d\n", $who, $tally_for{$who}->[0];
}
[download]

What's hard about this is that a correct solution is so simple. Here's one that works:

Vote counting and reporting take all of 15 lines with no golfing. Practically any deviation from a simple "stash in a hash" implementation is going to be suspicious. I think the best bet for really sneaking something in is to write a lot of bad code that mostly works. Another strategy might be to exploit a bug in some software that the machine uses (e.g., a MySQL bug) rather than have a bug in the machine itself.

Anyway, it's an interesting "problem" but having skulked about the Monastery for a while, I can't imagine I'd get anything past the monks.

Update: I should spoiler out an explanation. So, here's what my entry does "wrong":

Your comment in the spoiler made me think of this kind of an approach to
<Reveal this spoiler or all spoilers in this node or all in this thread>

use strict;
use warnings;

my @candidates = qw( Alice Bob );

## initialize each candidate with 0 votes
my %votes;
   @votes{map lc, @candidates} = ( [0] ) x @candidates;

print "Available candidates: @candidates\n";
print "To cast a vote, type candidate's name. End the election with ^D
+\n";

## record the input vote
while (<>) {
    chomp( my $vote = lc $_ );
    if ( exists $votes{$vote} ) {
        $votes{$vote}[0]++;
    } else {
        warn "Invalid candidate!\n";
    }
}

## print all votes
print "Final results:\n";
printf "%10s : %d\n", $_, $votes{lc $_}[0]
  for @candidates;
[download]

What it does wrong:
<Reveal this spoiler>

blokhead

Vote counting and reporting take all of 15 lines with no golfing. Practically any deviation from a simple "stash in a hash" implementation is going to be suspicious.

I'd have thought there was plenty of room for legitimate complexity.

For example, is it really reasonable that a user accidentally typing "Alcie" instead of "Alice" should effectively lose their vote? Of course not! Clearly, to make sure that every vote is correctly recorded, we need much more sophisticated validation routines...

See also The Underhanded C Contest which was also inspired by that contest.

Likewise, the results of the election should be plausible. If all votes go to one candidate, or the number of votes is vastly different than what was entered, people will get suspicious!

The trick here is that there are good statistical ways of measuring what "vastly different" means. In practice, it's only possible to swing the vote by 1-2% within the software as long as election officials are practicing even the smallest amount of due diligence. While that would have been enough to swing the last two US Presidential elections and some congressional elections, it won't work in the general case.