Use the shoulders of an ancient genius :)
You could use Euclidean algorithm to find GCD. It's very simple: you can find info here. (http://www.nist.gov/dads/HTML/euclidalgo.html)

Great heavens, don't do all that. You don't have to find all the divisors just to find the greatest common divisor. Just use this:

sub gcd {
  my ($a, $b) = @_;
  ($a,$b) = ($b,$a) if $a > $b;
  while ($a) {
    ($a, $b) = ($b % $a, $a);
  }
  return $b;
}
[download]

--
Mark Dominus
Perl Paraphernalia

Actually Euclid's Elements were written about 2300 years ago. But we don't know whether or not he originated it. It is true that the first written record that we have of it is in Proposition VII.2. However we have no particular reason to believe that Euclid invented most of his results. All that we know is that he wrote the textbook.

And the algorithm was of practical use at the time for converting money from one currency to another. So for all we know it may have been in wide-spread use prior to Euclid. Or it might have been used by the Phoenicians from whom we have very few records, but who are known to have engaged in trade and were purportedly good with numbers. (But who were, of course, not on such good terms with Rome...)

The truth is that we simply don't know who came up with the results in Euclid's textbook.

An incidental piece of trivia. The Elements of Euclid is the single most often translated and published non-religious work in history. (The most often translated and published work is, of course, the Bible.)

This is an inelegant brute force approach:

my $num1 = 150;
my $num2 = 1000;

# set which is biggest and which smallest
my $max = ($num1 > $num2)? $num1 : $num2;
my $min = ($num1 < $num2)? $num1 : $num2;

for $divisor (reverse 0 .. $min) {
    # fail unless our divisor divides evenly into $min
    next if $min % $divisor;
    # fail unless our divisor divides evenly into $max
    next if $max % $divisor;
    print "Largest common divisor is $divisor\n";
  last;
}
[download]

This is O(n) in that the bigger the smaller number the longer this will take to run. For a more elegant approach use Euclid's recursive algorithm as suggested by larsen it is O(log $a * log $b) - ie so much more efficient it is not funny!:

print euclid(15000,1260);

sub euclid {
   my( $a, $b ) = @_;
 return ($b) ? euclid( $b, $a % $b ) : $a;
}
[download]

cheers

tachyon

s&&rsenoyhcatreve&&&s&n.+t&"$'$`$\"$\&"&ee&&y&srve&&d&&print

s&&q+\+blah+&oe&&s<hlab>}map{s}&&q+}}+;;s;\+;;g;y;ahlb;veaD;&&print;
[download]

# insert these 3 lines if arrays aren't sequential
sub numerical {$a <=> $b}
@array_1 = sort numerical @array_1;
@array_2 = sort numerical @array_2;

my $array_1 = pop @array_1;
my $array_2 = pop @array_2;
while (@array_1) {
    if ($array_1 > $array_2) {
        $array_1 = pop @array_1;
    }
    elsif ($array_2 > $array_1) {
        $array_2 = pop @array_2;
    }
    else {
        print "highest common divisor = $array_2\n";
        last;
    }
}
[download]