RogerBW's Blog

I’ve been doing the Weekly Challenges. The latest involved findind odd abundant numbers and first-class functions. (Note that this is open until 3 July 2022.)

Task 1: Abundant Number

Write a script to generate first 20 Abundant Odd Numbers.

An abundant number being one where all proper divisors (including 1 but not itself) sum to more than the number. This sequence is of course in the OEIS.

I'd already written a divisors function for Challenge 156 Task 2, so I adapted that to make an abundance tester. But not in Perl, where I used Math::Prime::Util.

use Math::Prime::Util qw(divisor_sum);

sub oddabundant($ct) {
  my $n = 1;
  my @o;
  while (1) {
    if (divisor_sum($n) > $n * 2) {
      push @o,$n;
      if (scalar @o >= $ct) {
        last;
      }
    }
    $n += 2;
  }
  return \@o;
}

In Raku, the tester (note that I can short-circuit the division process if the divisor sum already exceeds the input):

sub abundant($n) {
    if ($n==1) {
        return False;
    }
    my $ff=1;
    my $s=floor(sqrt($n));
    if ($s * $s == $n) {
        $ff += $s;
        $s--;
    }
    for 2..$s -> $pf {
        if ($n % $pf == 0) {
            $ff += $pf;
            $ff += $n div $pf;
            if ($ff > $n) {
                return True;
            }
        }
    }
    return False;
}

and the primary function looks much like the Perl version.

sub oddabundant($ct) {
  my $n = 1;
  my @o;
  while (True) {
    if (abundant($n)) {
      @o.push($n);
      if (@o.elems >= $ct) {
        last;
      }
    }
    $n += 2;
  }
  return @o;
}

Task 2: First-class Function

Create sub compose($f, $g) which takes in two parameters $f and $g as subroutine refs and returns subroutine ref i.e. compose($f, $g)->($x) = $f->($g->($x)).

I don't generally go this deep into functional programming, but it turns out that all nine of the languages I'm using can do this, with more or less facility.

Lua:

local f = function(x)
   return x + 1
end

local g = function(x)
   return x * 2
end

function compose (f1, f2)
   return function(x)
      return f1(f2(x))
   end
end

local h = compose(f, g)

PostScript (where an executable procedure is just an array with an "executable" flag):

/compose {
    3 dict begin
    /f1 exch cvlit def
    /f2 exch cvlit def
    /o f1 length f2 length add array def
    o 0 f1 putinterval
    o f1 length f2 putinterval
    o cvx
    end
} bind def

/f {
  1 add
} bind def

/g {
  2 mul
} bind def

/h { f } { g } compose bind def

Kotlin (where the hard part is working out how to declare the various types:

fun compose(f1: (Int) -> Int, f2: (Int) -> Int): (Int) -> Int {
    return fun(x: Int): Int = f1(f2(x))
}

val f = fun (x: Int): Int = x + 1
val g = fun (x: Int): Int = x * 2
val h = compose(f, g)

Raku:

my $f = sub {return @_[0] + 1};
my $g = sub {return @_[0] * 2};
my $h = compose($f,$g);

sub compose($f1,$f2) {
  return sub {
    $f1.($f2.(@_[0]));
  }
}

and Perl:

my $f = sub {return $_[0] + 1};
my $g = sub {return $_[0] * 2};
my $h = compose($f,$g);

sub compose($f1,$f2) {
  return sub {
    $f1->($f2->($_[0]));
  }
}

Python, which gets explicit with the lambdas:

def compose(f1,f2):
  return lambda x: f1(f2(x))

f = lambda x: x + 1
g = lambda x: x * 2
h = compose(f,g)

And so does Ruby:

def compose(f1,f2)
  return lambda { |x| f1.call(f2.call(x)) }
end

f = lambda { |x| return x+1 }
g = lambda { |x| return x*2 }
h = compose(f,g)

JavaScript:

let f = function(x) { return x+1 };
let g = function(x) { return x*2 };

function compose(f1,f2) {
    return function(x) { return f1(f2(x)) };
}

let h = compose(f,g);

and finally Rust, which I don't really understand :

let f = |x| x + 1;
let g = |x| x * 2;
let h = compose(f, g);

fn compose<A, B, C, G, F>(f: F, g: G) -> impl Fn(A) -> C
where
    F: Fn(B) -> C,
    G: Fn(A) -> B,
{
    move |x| f(g(x))
}

Full code on github.