RogerBW's Blog

I've been doing the Perl Weekly Challenges. This one dealt with difference series and prime factorisation.

I used difference series before in my answer to challenge #15, though there wasn't any code in common with this one.

use Getopt::Std;

my %o=('d' => 2);
getopts('d:',\%o);
my @seq=@ARGV;

foreach (1..$o{d}) {
  my @o=map {$seq[$_+1]-$seq[$_]} (0..$#seq-1);
  @seq=@o;
}

print join(' ',@seq),"\n";

Perl6 is much the same, only Getopt::Std isn't available so I just take the depth as the first argument. All the other changes are minor.

my @seq=@*ARGS;
my $depth=shift @seq;

The other challenge was prime factorisation, where I decided to use a straightforward trial division with some minor optimisations. (For numbers small enough to use them, this is rather faster with native integer types than with BigIntegers; use integer;.)

use Math::BigInt lib => 'GMP';

foreach my $i (@ARGV) {
  my $f=primefactor(Math::BigInt->new($i));
  my @o="$i:";
  foreach my $ff (sort {$a <=> $b} keys %{$f}) {
    push @o,($ff) x $f->{$ff};
  }
  print join(' ',@o),"\n";
}

sub primefactor {
  my $n=shift;
  my %out;
  while ($n%2 == 0) {
    $out{2}++;
    $n/=2;
  }
  my $k=Math::BigInt->new(3);
  while ($k*$k <= $n) {
    while ($n % $k == 0) {
      $out{$k}++;
      $n /= $k;
    }
    $k+=2;
  }
  $out{$n}++;
  return \%out;
}

Again, the perl6 version is very similar except for minor syntax changes, and using native integer types. I did try putting an is-prime test into the loop, but this takes rather longer than just doing the first trial modulus, failing, and moving on.