# RabbitFarm

## Part 1

``````
use strict;
use warnings;
##
# You are given an unsorted list of integers @N.
# Write a script to find out the smallest positive number missing.
##
sub least_missing{
my(@numbers) = @_;
@numbers = sort @numbers;
for my \$i (\$numbers .. \$numbers[@numbers - 1]){
my @a = grep { \$_ == \$i } @numbers;
return \$i if(!@a && \$i > 0);
}
return undef;
}

MAIN:{
my @N;
@N = (5, 2, -2, 0);
my \$least_missing = least_missing(@N);
print "The least mising number from (" .
join(",", @N) . ") is \$least_missing\n";
@N = (1, 8, -1);
\$least_missing = least_missing(@N);
print "The least mising number from (" .
join(",", @N) . ") is \$least_missing\n";
@N = (2, 0, -1);
\$least_missing = least_missing(@N);
print "The least mising number from (" .
join(",", @N) . ") is \$least_missing\n";
}
``````

### Sample Run

``````\$ perl perl/ch-1.pl
The least mising number from (5,2,-2,0) is 1
The least mising number from (1,8,-1) is 2
The least mising number from (2,0,-1) is 1``````

The list is given in arbitrary order so the first thing to do is to sort it. Once in sorted order iterate from the least number to the highest, incrementing by one at each step. Perl makes this easy with the range (aka flip-flop) operator. Each each iteration see if the current number is from the original list or not and if not, then if it is the smallest positive number not yet seen, which really just means the first positive number not from the original list.

As I am writing this I realize that it’d make sense to use grep to remove all the negative numbers from the list before even bothering to sort them. If the list were presented as, say, 1 million negative numbers and then three positive ones why waste doing anything with all the negatives!

## Part 2

``````
use strict;
use warnings;
##
# You are given rankings of @N candidates.
# Write a script to find out the total candies needed for all candidates.
#     a) You must given at least one candy to each candidate.
#     b) Candidate with higher ranking get more candies than their immediate
#        neighbors on either side.
##
sub count_candies{
my(@candidates) = @_;
my \$candies = @candidates;
for my \$i (0 .. (@candidates - 1)){
if(\$candidates[\$i - 1]){
\$candies++ if \$candidates[\$i] > \$candidates[\$i - 1];
}
if(\$candidates[\$i + 1]){
\$candies++ if \$candidates[\$i] > \$candidates[\$i + 1];
}
}
return \$candies;
}

MAIN:{
my @N;
my \$number_candies;
@N = (1, 2, 2);
\$number_candies = count_candies(@N);
print "The number of candies for (" .
join(",", @N) . ") is \$number_candies\n";
@N = (1, 4, 3, 2);
\$number_candies = count_candies(@N);
print "The number of candies for (" .
join(",", @N) . ") is \$number_candies\n";
}
``````

### Sample Run

``````\$ perl perl/ch-2.pl
The number of candies for (1,2,2) is 4
The number of candies for (1,4,3,2) is 7``````

### Notes

I don’t think there are any surprises in this approach. In fact, I could not think of a better way, in terms of efficiency, than this. Still, this is not exactly exciting code to read!