DEV Community: Simon Proctor

I like things to be easy

Simon Proctor — Thu, 14 Apr 2022 12:15:28 +0000

The Situation

You've got a large JSON file, in my case 21MB, that takes a while to parse. You want to have a web service running that can load this file into memory and server data from it. Nice and simple right? Sure the initial data read might take a few seconds but after that the service can just trundle along.

Here's a simple example using Cro.

use JSON::Fast;
use Cro::HTTP::Router;
use Cro::HTTP::Server;

constant DATAFILE = 'data.json';
my $data = from-json($data)

my $application = route {
    get -> 'count' {
        content 'text/plain', "{$data.keys.elems}\n";
    }
    get -> 'keys' {
        content 'text/plain', "{$data.keys.join(",")}\n";
    }
    get -> $uid {
        not-found unless $data{$uid}:exists;
        content 'text/plain', "{$data{$uid}.keys.join(",")}\n";
    }
    get -> $uid, $cid {
        not-found unless ($data{$uid}:exists) && ($data{$uid}{$cid}:exists);
        content 'text/plain', "{$data{$uid}{$cid}}\n";
    }
}

my Cro::Service $server = Cro::HTTP::Server.new:
    :host<localhost>, :port<5000>, :$application;

$server.start;
react whenever signal(SIGINT) {
    $server.stop;
    exit;
}

(Most of this is cribbed from the Cro docs to be honest.)

$data is read at the start and then shared between our threads. (Note it's a two level data structure but that's not that important for the example). The data is immutable and everything is fine.

The wrinkle

Every once in a while the data file gets updated. When this happens we have a bunch of rules we need to apply :

it's OK for a request to server stale data for a bit
request should return in a timely fashion (so no 3 second waits to read our data file allowed)
the server should always serve response (so we can't just reboot the server).

Now we could fire up a new server and swap them in a proxying system, that wouldn't be too hard. But what if we could hot swap the data and keep the server running?

A solution

It might not be the solution, feel free to comment with others but here's what I came up with.

unit class JSONDataWatcher;

use JSON::Fast;

subset DataFilePath of Str:D where *.IO:e && *.IO.f;

has DataFilePath $!datafile;
has $.data;
has Lock $!lock;

method !update-data {
    my $read;
    try {
        $read = from-json( $!datafile.IO.slurp );
    }
    $!lock.protect( {$!data = $read} ) unless $!;
}

submethod BUILD( DataFilePath:D :$!datafile ) {
    $!lock = Lock.new();
    self!update-data();
    start react {
        whenever $!datafile.IO.watch() {
           self!update-data();
        }
    }
}

Here was have a JSONDataWatcher class. You give it a file path and it does a couple of things :

Parses the JSON file and puts it in it's $.data value
Sets up a watcher on the file path if the file changes it tries to reload and update the data.
- If the data parsing fails (which if the file hasn't finished being written could well happen) we ignore it and keep using the old data
- If it parses OK we lock the data attribute while we update it. This will give us a small blip when doing reads but I figure it's safer.

Then we can update our server so :

use JSONDataWatcher;
use Cro::HTTP::Router;
use Cro::HTTP::Server;

constant DATAFILE = 'data.json';
my $w = JSONDataWatcher( datafile => DATAFILE );

my $application = route {
    get -> 'count' {
        content 'text/plain', "{$w.data.keys.elems}\n";
    }
    get -> 'keys' {
        content 'text/plain', "{$w.data.keys.join(",")}\n";
    }
    get -> $uid {
        not-found unless $w.data{$uid}:exists;
        content 'text/plain', "{$w.data{$uid}.keys.join(",")}\n";
    }
    get -> $uid, $cid {
        not-found unless ($w.data{$uid}:exists) && ($data{$uid}{$cid}:exists);
        content 'text/plain', "{$w.data{$uid}{$cid}}\n";
    }
}

my Cro::Service $server = Cro::HTTP::Server.new:
    :host<localhost>, :port<5000>, :$application;

$server.start;
react whenever signal(SIGINT) {
    $server.stop;
    exit;
}

Notes

This is all a bit rough and ready, there's some error checking I'd add. But I thought it would be interesting to show what you can do with Raku. Note that apart from the data parsing everything in the JSONDataWatcher class is core to the language.

Enjoy and stay safe.

The Weekly Challenge : Week 133 in Raku

Simon Proctor — Fri, 08 Oct 2021 13:16:55 +0000

Back to the Challenges

So it's been a while since I blogged about the Weekly Challenges. Heck I've been a bit up and down due to everything going on and haven't even done them every week.

But I'm back on the wagon off to the races or something, so lets look at this weeks challenges.

Challenge 1

Now Raku doesn't have a isqrt functions built in and the challenge states not to use built in functions. Still if we were allowed it it's pretty simple.

sub isqrt( UInt \n ) { \n.sqrt.Int() }

Cue discussion in /r/rakulang about which method I should have used to round the value off. It's beside the point for the case in point because we're here to talk about how to calculate it without using built in functions.

One thing to note, on my laptop doing iqsrt(999999999999999) using that method takes about 0.14 seconds.

So there's lots of Maths on Wikipedia dealing with calculating integer square roots but as is my wont I figured lets try something simple. Count from 1 to Infinity until I find a number that when squared is bigger than the number I'm looking for. The number before it will be the integer square root.

Sure for a human that's insanely tedious but doing insanely tedious counting is what we invented computers for. Here's the code for that :

sub isqrt(UInt \n) {
    (1..*).first( { $_ * $_ > n } ) - 1;
};

So... make the Range 1 to Infinity (here denoted by a * but I could use the ∞ symbol if I wanted. I tend to not use Unicode much though as it's a pain to type) and find the first value that when squared is bigger that the target. (I love first it's like grep but when you just want the first thing. Then we just subtract one and return. Simples.

(And yes $_² or $_ ** 2 would work too... but... does it make a huge difference? I don't think so.)

And there we go. Interesting thing to note if you time iqsrt(999999999999999) using this method it's about .2s. Not too bad (though... it's not a linear progression... add 5 more 9's and it's slows to just over a second).

Another method I saw was to use a Sequence with the check in the terminator, something like this :

sub isqrt(UInt \n) {
    (1...*² > n)[*-2]
}

(See I can use fancy unicode stuff if I want to). And that works except... it takes over 1 second to calculate iqsrt(999999999999999) and for 15 9's I get bored waiting. (I do get bored easily though).

So... yeah, Sequences are fun but a whole bunch slower than a Range.

Challenge 2

So this challenges is about Smith Numbers and a quick look at the Wikipedia page we see that we need prime factors. Luckily if you've been doing the Weekly challenge (almost every week...) then this is not your prime factor rodeo. Challenge 41 required to find prime factors so a quick duck into the archives and I find this:

use experimental :cached;

sub prime-factors( Int $n is copy --> Array ) is pure {
    my @factors;
    while ! $n.is-prime {
        my \s = smallest-factor( $n );
        @factors.push(s);
        $n = $n div s;
    }
    @factors.push($n);
    return @factors;
}

sub smallest-factor( Int \n --> Int ) is pure is cached {
    for (2..(n div 2)).grep(*.is-prime) {
        return $_ if n %% $_;
    }
    die "Something went wrong";
}

So here we do recursive sub division of a number to find the smallest prime factor and put them into a list. (This is made a lot easier by is-prime and %%. So now we want to find the Smith numbers, specifically the first ten. In my (get computers to count lots for you) way I figure this is a job for a Range and grep!

Generally I find many things I attempt are a job for map, grep and reduce.

So here's our Main sub:

sub MAIN ( UInt \n = 10 ) {
    .say for (2..*).grep( { is-smith-number($_) } )[^n];
}

Simple right...

...

Oh... you want to see what is-smith-number has in it. Well there are two possibilities. Firstly the number is prime in which case it's not a Smith number so that's simple :

multi sub is-smith-number( Int \n where n.is-prime --> False ) {}

Here I'm using a trick I picked up for this sort of case to put the return directly into the signature which feels Rakuish.

And then there's the case where it isn't prime. Here we sum the values of the number and for each factor sum the sum of each value... Look here's the code hopefully it will make sense :

multi sub is-smith-number( Int \n --> Bool ) is pure {
    my @factors = prime-factors( n );
    ([+] n.comb) == ([+] @factors.map( { [+] $_.comb } ));
}

[+] $var.comb casts a number to a string and then splits it it's individual values and then does a recursive addition to get the sum. If the sun of the values equals the sum of the sum of the values of each factor then it's a Smith number.

As I mentioned timings before that takes about 0.3s to calculate the first 10 Smith Numbers (and 0.5s for the first 100). Once the new-disp branch has been released as stable I'll maybe run it again and see if it changes at all (the multi call should hopefully be a bit faster).

Anyway, there we go, enjoy the challenge, hopefully I'll write more next week.

Why not reduction?

Simon Proctor — Thu, 30 Sep 2021 14:11:27 +0000

So it's been a while since I posted here but a post on the Weekly Challenge number 131 made me want to share my solution. The blog post by glfdex was inspired by this one by Falvio. Anyway I looked at both of these and wondered... "Why didn't they use reduction?"

An Aside

For those of you who don't know, reduction is one of the core list processing utilities. I tend to use it alot in the form of the Reduction Meta operator which works something like this.

Given a list a,b,c,d,e apply the operation to a and b, then apply the operation to the result of that and C and so one. So an example :

say [+] 1,2,3,4,5,6

is the same as writing :

say (((((1+2)+3)+4)+5)+6)

but as well as the reduction operator Raku also has the reduce method which takes a pair of inputs and returns a single result.

Back to the challenge

So I want to use reduce to solve this. Lets start with a simple wrapper :

sub MAIN( *@vals where *.all ~~ Int() ) {
    @vals.reduce(
        ... # Insert reduction here
    ).say;
}

So if we want to use reduce we want it to return an Array of Arrays, but this means our reduction is going to receive such an array for it's first value. But not at the start of the list... Still that's not too hard to deal with.

sub MAIN( *@vals where *.all ~~ Int() ) {
    @vals.reduce(
        -> $v1 is copy, $v2 {
            if $v1 ~~ Int(Str) {
                $v1 = [[$v1],]
            }
            ...
            $v1
        }
    ).say;
}

So we make our first value a copy so we can modify it (other wise it's immutable, which is good generally). If it's an Integer (or more generally an IntStr allomorph) we turn it into an Array with a single element (an Array containing the value). We need the trailing comma there or we fall foul to the single argument rule.

Now we can do the bulk of our code. Which is pretty simple really. If $v2 is equal to 1 more than the last item in the last array in $v1 which append it to the list. Otherwise we append a new array containing $v2.... that was simple right... Look here's the code.

sub MAIN( *@vals where *.all ~~ Int() ) {
    @vals.reduce(
        -> $v1 is copy, $v2 {
            if $v1 ~~ Int(Str) {
                $v1 = [[$v1],]
            }
            if $v1[*-1][*-1] ~~ $v2-1 {
                $v1[*-1].push($v2)
            } else {
                $v1.push( [ $v2, ] )
            }
            $v1
        }
    ).say;
}

And there we go. A nice simple reduction that goes through the list... But looking at it I think it can be better. Really we don't want to be copying and pushing to lists, that reduces our ability to split it into multiple jobs. Which isn't an issue with a few items but what if we had a list of 100,000? Wouldn't it be nice to just add a hyper and let all our cores do something with it?

... So I did a bit of experimenting and it doesn't play as nice with hyper as I hoped but here's a more purely functional version of the reduction.

sub group-vals (@vals) {
    return lazy @vals.map( { (($_,),) } ).reduce(&join-list);
}

sub join-list( \l1, \l2 ) {
    if ( l1[*-1][*-1]+1 ~~ l2[0][0] ) {
        (
            |(l1.elems > 1 ?? l1[0..^*-1] !! Empty),
            (|l1[*-1], |l2[0],),
            |(l2.elems > 1 ?? l2[1..*] !! Empty )
        );
    } else {
        (|l1, |l2);
    }
}

So firstly we assume that the caller handles the printing and instead return a lazy list (so if we don't need all of it we can skip it). Then we make our list into a list of lists and now we can reduce it.

Our reduction now takes two lists of lists. We either want to join them or not depending on the items at the end and start of each. For example :

((1,2),(3)) and ((4))

Here the 3 and 4 are in sequence so we join them into :

((1,2),(3,4))

Note that this code can handle if the second list is longer than a single character. So I think for big lists (up to 10,000 hyper does fine) I need to break it into small lists and reduce each of them then do a second final reduction on the result.

Anyway.... that how I handled it. Enjoy.

Weekly Challenge in Raku : Week 79 Retrospective

Simon Proctor — Wed, 30 Sep 2020 13:09:14 +0000

Is this thing on?

With everything going on in the world I've been finding it hard to write stuff. But today the review of Week 79 of the weekly challenge was released. Andrew does an amazing job of going over the various Raku challenges and I've got to admit I love watching him go over my code. It's always good (and often nice) to see how other people react to your code. As a developer I have my code reviewed often and having it done in video is just great.

Watching the review I realised that I'd got into a situation I often get into which is latching onto a solution and not considering others. Firstly you need to bear in mind Challenge 75 which also involved histograms and I quite liked my code I wrote to draw them for that challenge.

(It is I know a bit over the top, I got a bit into my functional programming weeds there). But anyway, because I already had code to draw a histogram I figured I'd reuse that and repurpose it for this challenge.

The perils of cut and paste.

Cut and paste programming has lots going for it, it lets you get moving when a blank screen can leave you pulling out your hair. But it's also terrible for sending you down paths because of the ideas employed in the original code.

In this case I got caught up on the idea of calculating the area of a rectangle.

A simple example

Take the array of heights 3,0,0,0,3 this gives this histogram. (We assume there is a floor and water doesn't fall out the bottom).

#   #     #~~~#
#   #  => #~~~#
#   #     #~~~#

As we can see this has 9 squares of rain water and the area calculation is the width times the height or 3 x 3 = 9 nice and simple. (At this point I've started down the path which takes me all kinds of fun place).

Adding a floor

Of course generally all our heights are greater than 0 giving us a nice floor so here's another simple array 3,1,1,1,3.

#   #     #~~~#
#   #  => #~~~#
#####     #####

Here are area is 6, the calculation for this is the width inside (3) times the height of the edges (3) minus the sum of the internal heights (1+1+1). Giving us (3 x 3) - (1+1+1) = 6. Of course this is still a simple example.

(Note that this calculation still holds true for our original case it's just the internal heights sum up to 0).

Complication 1 : Different edge heights

So I'm still trundling along with my plan, it's making sense so far. But what if out edges have different heights? Lets try 5,1,1,1,3 and what do we get?

#         #
#         #
#   #  => #~~~#
#   #     #~~~#
#####     #####

Still 6 squares and it's easy to see our algorithm still works. We just use the height of the smaller edge for the height of the area. (3 x 3) - (1+1+1) = 6 nice and easy. At this point I felt I was on a winner.

Complication 2 : Rough ground

What if the floor isn't nice and smooth? Lets give this array a shot 4,1,2,1,3,4 and see :

#   #     #~~~#
#  ##  => #~~##
# ###     #~###
#####     #####

So our algorithm gives us a height of 4 and a width of 3 and inner heights of 1+2+3 = 6 so this comes to (4 x 3) - 6 = 6 and as we can see that's right.

So at this point I'm feeling pretty awesome... of course here's where it starts to fall apart.

The centre cannot hold

What if there's a spike in the middle? A point higher than the edges? Like 3,1,4,1,3 :

  #         #
# # #  => #~#~#
# # #     #~#~#
#####     #####

So our algorithm is going to get the smallest edge 3 and the width 3 and the internal heights 1+4+1 = 6 and we get (3 x 3) - 6 = 3... And that's wrong.

So here is where I probably should have taken a step back and wondered if there was a better way, but I was on a roll. Simple change to the algorithm now when summing the height was count either the height in the array or our minimum side height whichever is smaller.

This is a warning note really, if your simple algorithm is starting to have extra checks in it then you're maybe going the wrong way. It's also a warning that's really easy to spot in hindsight.

Anyway with that in place we now have (3 x 3) - (1 + 3 + 1) = 4 and we're done!

I actually thought I was finished at this point. I messed around with a few more arrays and then.... oh boy.

The slope to heck

Lets try something else I mean we've got an awesome algorithm right? 1,2,5,1,4 should look good.

  #        #
  # #      #~#
  # # =>   #~#
 ## #     ##~#
#####    #####

At this point the algorithm completely collapses giving (1 x 3) - (1+1+1) = 0.

Step away from the keyboard

There are moments when you need to step back. Which I did but... not that far back. See the algorithm worked for a lot of cases looking at this one I could see it could be considered 2 separate arrays.

  #        #   #
  # #      #   #~#
  # # =>   # + #~#
 ## #     ##   #~#
#####    ###   ###

1,2,5 and 5,1,4 with that we get two passes of the algorithm for the first we have a height of 1 a width of 1 and internal height of 1 so (1 x 1) - 1 = 0. Meanwhile we have in the second array we have a height of 4 a width of 1 and and internal height total of 1 so (4 x 1) - 1 = 3 add those up and you get 3. So the algorithm works from discrete chunks of the map.

At this point the functional programmer in me is reaching for the recursion hat. Raku multi method make it really easy to do a recursive function like this so in the end I found 3 cases :

There is a spike taller than the edges in the centre section
- In this case we want to split our array into two sub arrays and check each of them
There is only 1 or two items in the array
- In that case we always return nothing, there will be no rain fall. This is the case that Andrew didn't spot in the review.
The two edges are the highest possible and there is at least 1 space in between
- Calculate the area using our simple algorithm

The code for this is as follows :

Firstly case 1. Where there is a spike inside a heights array. Note we pass an offset so the drawing code knows where this water is.

multi sub calculate-rain-levels( 
  @heights where { 
    any(@heights[0^..^*-1]) > any(@heights[0],@heights[*-1])  
  }, 
  $offset = 0
) {
  my $max = max(@heights[0^..^*-1]);
  # This is a bad name... it's really the first
  # Index of a height greater than the edges. 
  my $mid-idx = @heights[0^..^*-1].kv.map( 
    -> $k, $v { $v == $max ?? $k+1 !! Empty } )[0];

  # As calculate-rain-levels returns an array we slip it so
  # we don't end up with nested array.
  return ( 
    |calculate-rain-levels( @heights[0..$mid-idx],$offset ),
    |calculate-rain-levels( @heights[$mid-idx..*],$mid-idx+$offset ) 
  )
}

Case 3. Here we match again and were only accepting arrays with 3 or more values.

multi sub calculate-rain-levels( 
  @heights where { @heights.elems > 2 }, 
  $offset=0 
) {
  # Here is our simplified algorithm
  # Get the highest edge
  my $height = min( @heights[0], @heights[*-1] );
  # Area = height * width on the inside
  my $area = $height * ( @heights.elems - 2 );
  # Then remove the floors, no need to check the height.
  $area -= [+] @heights[0^..^*-1];
  # RainArea is a data transfer object that is used by the
  # drawing system
  return RainArea.new( 
    range => ( $offset..^($offset+@heights.elems) ), 
    :$area, 
    :$height 
  ); 
}

Case 2 (one or two items) is now the fallback case where we just want to return nothing. We use anonymous variables in the signature because we don't care about them

multi sub calculate-rain-levels(@,$) { Empty }

And there we go.

Hopefully this makes some sort of sense of the rambling thread of logic I followed to finish this challenge. Thanks again the Mohammad for all his work managing the challenge to Andrew for his Raku reviews and to everyone who takes part. I always enjoy Monday mornings brain teaser.

Have fun all and be well in this difficult times.

The Weekly Challenge in Raku : Week 72 (Part 2)

Simon Proctor — Tue, 04 Aug 2020 08:27:24 +0000

So Part 1 was interesting and I've got a final coda to that. Here's probably the smallest and fastest way to solve the challenge.

unit sub MAIN( UInt $N where * <= 10 );
say '00000111112'.comb[$N];

...

Yup. So lets break this down. First up the unit declarator says everything in the current file is part of the MAIN sub. It's not really required but I liked it.

'00000111112'.comb takes the string and splits it into a list. It's a bit shorter than writing the list with commas. Then we simply look up the index for $N in the list.

This works because of the restriction on $N that it can't be greater than 10 so we can pre-calculate the results. This may seem like "cheating" but it's an important trick for a developer to have. Sometimes it's faster to pre-calculate and cache data than it to make it on the fly.

Anyway onto the second task.

Task 2

So for this one I'm just going to share my whole answer and then go over what it's doing :

subset FilePath of Str where *.IO:f;

#| Read and output lines A -> B in the given text file
sub MAIN (
    UInt $A where * > 0, #= Start line
    UInt $B where * >= $A, #= End line
    FilePath :f(:$file) = "test-file.txt", #= Text file to read
) {
    .say for $file.IO.lines[$A-1..$B-1];
}

Yes. The answer is 1 line of code. Everything else is validating input values, this is my favourite kind of function. Especially when the input validation is not done inside the function.

For the validation we firstly define a subset of the Str type. Subsets are effectively named where clauses which make the code easier to read and also make the computed Usage message nicer to read as well.

The where clause casts our String to an IO object (treating it as a path) and then checks there's a file at that location.

Note the UInt is a subset of Int and that as with $A and $B you can combine a subset and an additonal where clause. Also as in $B you can reference other parameters in your where clauses.

In all I love this signature for displaying the power of signatures in Raku it allows you to take a lot of the boiler plate for validation and shift it up, often allowing for compile time checking.

And now the meat of the function. $file.IO makes an IO::Path object that points to the file we want to read. Then we call the lines method to get a sequence that returns lines in the file. (This is evaluated lazily which is nice).

Next we slice the sequence from $A-1 (as the challenge specifies indexing from 1 and Raku indexes from 0) to $B-1 and finally print each line with the .say method. When you call for and don't define the variable it uses $_ and when you call a method without an object you use $_ so bingo.

One of the things I love about Raku is it's ability to make things that you need to do often really really simple. Leaving you time to focus on the interesting problems.

The Weekly Challenge in Raku : Week 72 (Part 1)

Simon Proctor — Mon, 03 Aug 2020 13:15:44 +0000

This weeks challenge is not going to be too taxing. There are a few fun little bits we can do though.

Part 1 : Trailing Zeros

In this challenge we're to find the number of trailing Zero's in $N! where $N <= 10 so really it's a two part challenge, find $N! and count trailing zeros.

Finding Factorials

First thing to note is we can define the ! factorial operator quite easily :

sub postfix:<!> (UInt $N) {...}

We'll cover the ... bit in a sec but this defines ! as a postfix operator that requires and Unsigned Integer in front of it. Thing is I won't be using this in my challenge because right now defining operators directly in scripts really slows down parsing (if you put them in Modules you get them precompiled but generally I don't make a module for the challenges).

Still it's nice to know you can do it. Anyway lets say we instead make a fact($N) sub how hard is that?

Personally I can think of three different ways of doing it off the top of my head, all of which are quite Rakuish so lets cover them each.

Sequences are fun

A Raku Seq is a iterable object that returns values that are generally calculated as required. There's a couple of sequences that can provide factorials. This first uses the ... Sequence operator

@F = (1,{$_ * $++}...*)

Here we define our starting condition @F[0] == 1 then our iterator in this $_ is given the value of the previous item in the list and $ is a local state variable. This will be 1 in the first iteration so @F[1] == 1 and then 2, 3 and so on. We use * as the final condition meaning we will keep generating values forever, but as sequences are lazy this doesn't cause our code to die.

Another way to create a Sequence would be to use [gather and take]{https://docs.raku.org/syntax/gather%20take} to explictly define it :

my @F = lazy gather { 
    my $idx = 1; 
    my $val = 1; 
    loop {
        take $val;
        $val *= $idx++; 
    }
};

A bit more wordy but sometimes this can be good. For a simple sequence like this it's probably over kill but in other cases you may fine it useful.

Recursion is fun too

A classic way to do factorials (and in some languages the only way) is to use recursion. Raku lends itself to this with multi subs for example :

multi sub fact( 0 ) { 1 }

multi sub fact( UInt $N ) { $N * fact( $N - 1 ) }

Here fact will recursively call itself until $N is 1 at which point the fact(0) call will match and the stack can unroll.

This is probably safe to do as in this challenge $N can't go over 10 but it's dangerous to rely on otherwise as you may get stack overflows. Still nice to know it's easy enough.

Meta Ops are your friends

When I did the challenge my first thought was to turn to Meta Operators. As 5! can be written as 1 * 2 * 3 * 4 * 5 this looks to me like a reduction on the list (1,2,3,4,5) with the * operator. the [] reduction metaoperator lets you write this like so :

sub fact(UInt $N) { [*] (1..$N) }

Note this works for 0 as the Range 1..0 is the list (1).

Finding the Trailing Zeros.

So we've got our factorial using one of the above options how do we find trailing zeros? Well as an old school Perl dev the first thing that comes to my mind is to use a Regex. The expression 0*$ will match 0 or more 0's at the end of a string. We then can count the length of this match and return it:

say (fact($N) ~~ m!(0*)$!)[0].Str.codes;

We get a Match object and can get it's zeroth value which is the first capture (here's a difference in Raku Regexes, captures start at 0). We coerce this to a Str and then count the code points. And Bingo, the count of trailing 0's.

And here's Part 2

Perl Weekly Challenge in Raku Week 71 (Part 1)

Simon Proctor — Tue, 28 Jul 2020 15:55:41 +0000

Sorry I've been away for a while I've actually been plugging away at the Challenges for a while I've just not felt the energy to Blog about then. Partly I've been busy and partly well... 2020 you know how it is.

But I figured I should get back on the horse with Week 71.

Challenge 1

So Challenge 1 asked you to generate a list of length 2 to 50 unique random positive integers. Then print the lists of peaks, a peak being defined as a number in the list higher than the two numbers next to it. Sounds fun, let's dive in.

Firstly we want our list size ($N) that needs to be between 2 and 50. We can put this in a MAIN sub with some documentation so we can run the script from the command line.

#| Generate a list of random numbers then find the peaks
sub MAIN(
    UInt $N 
    where 1 < * <= 50 #= Size of random number list
) {
    ...
}

As usual I'm using the #| and #= comments to add documentation to the function that will auto print if you run it with -? or incorrect input.

$N has a where clause that makes use of a Whatever Star to generate a code block and also operator chaining to easily test that 1 < $N and $N <= 50.

So now we want to make a list of random unique numbers between 1 and 50 up to $N in length. Luckily there's an app for that!

Well a method, pick picks a random number from a list in this in this way it's similar to roll and if you just call list.pick and list.roll you'll get a single random item in the list.

The difference comes when you call then with an integer value. In this case you get a Sequence of items from the list and here is where the two method diverge. list.roll(N) is like rolling a dice N times with all the items in the list on different sides. Each roll is distinct and the same number can come up twice.

list.pick(N) is list picking N cards from a deck. You don't put them back into the deck until you've finished picking... Which makes our code to make (or pick) the random list simple enough.

my @list = (1..50).pick($N);
say "List  : {@list.join(',')}";

This makes a random list of the numbers from 1 to 50 of length $N then prints it out. Ok... now to find the peaks.

First thing to bear in mind, for any given point $i in the list it's a peak if @list[$i-1] < @list[$i] > @list[$i+1] (note we don't need to worry about equality as the numbers are unique).

Another way to look at this is if you have a list of 3 numbers (@l) then the number in the middle of the list is a peak if @l[0] < @l[1] > @l[2]. I can see my old friend grep waving at me. We've come through thick and thin together and they've never let me down, sure they change their name in different places but I know if grep is around my life will be easier.

So I'm already seeing a plan, take the list, make it into a list of list where each is the current value and the numbers to either side. Grep for peaks then map comes in (you rarely find the two far apart) and pulls out the middle value again...

So this leaves us with two questions...

What about the start and end values?
How do we split the list up?

Generally when you're doing functional list based manipulation you want to avoid special cases (like how to handle to two ends of the list) as it complicates matters.

Of course we know that every number in the list if greater than 0 for if we put a 0 at each end of the list before dividing it into the lists of lists then we simplify things. Now our first list triplet will be (0, @list[0], @list[1]) and the test (0 < @list[0] > @list[1]) is functionally the same (in this case) as @list[0] > @list[1].

So our list of peaks starts simply enough :

@peaks = ( 0, |@list, 0 );

This uses the | operator to "slip" our list into the outer list creator (the brackets). If we don't do that you end up with 3 items in @peaks, one of which is a list...

Great so now we just have to divide this list into overlapping sets of three items.

It's at this point the inexperienced Raku developer will start writing a bunch of nested for loops and all this kind of stuff.

This isn't wrong but I often find that if I have a simple problem in Raku the first thing to do is Read the Docs. In this case we specifically want to look at the rotor method.

Rotor is a new friend of grep and map, Raku has brought a lot of friends to the "Lets play about with lists" party. Which is cool, especially when you realise just how many things count as "lists" for this.

But I digress. What rotor does is divide a list into sublists of a given length so :

(1,2,3,4).rotor(2) == ((1,2),(3,4))

Ok so this is starting to look right of only there was some where to say :

(1,2,3,4).rotor(THING) == ((1,2),(2,3),(3,4))

And do it for 3 items... well guess what, you totally can. Rotor has a lot of options on how you call it and I'm going to focus on one for this job.

If you call rotor and pass a Pair then it treat's this as length => offset and it will skip offset many items before making the next sub list.

Which is nice when you find that offset can be a negative, in which case you get overlapping sublists.

Our @peaks now becomes :

my @peaks = ( 0, |@list, |0 )
    .rotor(3 => -2)
    .grep( { $_[0] < $_[1] > $_[2] } )
    .map( { $_[1] } );
say "Peaks : {@peaks.join(',')}";

Get the list, split into sublists, grep for peaks, pull out the middle number. All nice and simple, no special cases and functional. If we wanted (and the list was longer) we could run these steps in parallel.

Nice and easy. Of course I've written a lot of stuff about what ended up being a 4 line bit of code. As the second solution is a bit longer I'll do a second post about it later.

Fingers crossed and 2020 willing.

Perl Weekly Challenge in Raku : Week 55

Simon Proctor — Tue, 07 Apr 2020 08:43:51 +0000

So it's been a few weeks, I don't know about you but I've been a bit stressed so blogging about the challenges has been a bit hard. Still I'm also lucky to be working in a job I enjoy from home. Stay safe everyone and lets take a look at this weeks challenges

Challenge 1

As is often the way my first thought on a challenge like this is to approach it with brute force and ignorance. I generally find that throwing computing power at the problem can often solve it quickly, if it doesn't I'll use my more valuable (and somewhat ageing) brainpower instead.

The first thing I decided was I'd represent my binary strings as Arrays, this is because I find bit twiddling annoying at the best of times and reserve it for instances when it's absolutely necessary. I value readability of my code and I just can't read masks and binary wibbly things all the easily.

So with that in mind here's a simple function that given an array of 1s and 0s plus a start and end index flips all the ones in between.

sub flip( @bin is copy, $l, $r ) {
    @bin[$l..$r] = @bin[$l..$r].map( { abs($_-1) } );
    @bin;
}

This makes use of a few neat things. Firstly you can assign to an array slice so we modify the slice and assign back into it. The second thing is that abs(x-1) for x=0 and x=1 returns the flipped value as abs(0-1) == abs(-1) == 1 and abs(1-1) == 0. So it makes the flipping itself nice and easy.

After that we just need to loop through all the possible values for l and r and keep track of the results with the most elements. For this we can use a stream cache, where we store the value of the most elements found and the list of all those results. For each new result if it's got more 1s than the current highest we reset the list of just have out new result and update the highest value. If it's got the same number of 1s we add it to the current list, otherwise we ignore it.

This is a useful trick when you're dealing with a stream of data and you know what you're looking but you don't know how much data you're going to have. Putting everything into a hash and iterating over that after can lead to memory issues.

Anyhow, here's the main loop.

#| Given a binary string find the start and end points
#| for flipping the bits that results in the most 1's
#| in the final string
sub MAIN( Str $bin where { m!^ <[10]>+ $! } ) {
    my @bin = $bin.comb;

    my @results;
    my $len = 0;

    for 0..@bin.elems-1 -> $l {
        for $l..@bin.elems-1 -> $r {
            my @res = flip(@bin,$l,$r);
            given @res.grep(* == 1).elems {
                when * > $len {
                    $len = $_;
                    @results = [ { l => $l, r => $r, bin => @res.join("") }, ];
                }
                when $len {
                    @results.push( { l => $l, r => $r, bin => @res.join("") } );
                }
            }
        }
    }
    say "Max 1's : {$len}";
    say "{$_<l>} -> {$_<r>} : {$_<bin>}" for @results;
}

Challenge 2

So Challenge 2 is about doing a Wave Sort, which is where a list a,b,c,d,e is sorted so that a >= b <= c >= d <= e and so on. There's probably a nifty way to make a custom infix operator that can handle this using chaining but I decided to go old school (Edinburgh University AI department in the 90's to be exact) and use the Prolog like abilities of the Raku Multi Dispatch model.

First up we need a way to get the unique permutations of a list. The challenge states your list can have non unique values in and the standard permutations method treats each element as unique so for the the (1,1) will give two results (1,1),(1,1) which is not what we want.

My original version of this got all the permutations joined them with commas and put the in a set to get the unique keys and split them up. The problem with this is permutations returns a Sequnece which is evaluated lazily whilst that had to calculate all the permutations before anything could be done.

So then I came up with a nest method involving gather / take and a hash to give a sequence of values.

And then while writing this I thought, surely Raku has a unique method? And lo and behold my final unique permissions sub:

sub unique-perms ( @input ) {
    @input.permutations.unique(:as(*.join(",")));
}

This uses the :as option to specific how to change the input for === comparison and it slightly fasted then using :with(&infix:<~~>). This gives us a sequence which means our code to check each permutation and see if it's valid is simple enough and can make use of race to give us simple threading.

#| Given a list of integers return all the wave sorted lists
multi sub MAIN( *@input where { $_.elems >= 2 && $_.all ~~ Int } ) {
    .say for unique-perms( @input ).race.grep( -> @l { is-wave( 'gte', |@l ) } );
}

...

Oh yeah. What's in is-wave and where's the Prolog you talked about?

So first thing you'll note is is-wave take a staring string argument of gte (for >=) and then take the array the permutation as a set of arguments by having the | slip operator in front (I believe some language use ... to do this?)

So lets go through some possible ways this function could be called :

multi sub is-wave( 'gte', Int $a, Int $b where { $b > $a }, *@ ) {
    False 
}

So if we call it with gte, two integers ($a and $b) and some more positional arguments *@ but $b is greater then $a we return False.

There are two other simple results :

multi sub is-wave( 'gte', Int $a, Int $b where { $a >= $b } ) { 
    True 
}
multi sub is-wave( 'gte', Int $a, Int $b where { $a < $b } ) { 
    False 
}

There's two cases where we call is-wave with gte and just two arguments. In on case $a is >= $b so we return True and in the other it isn't so we return False

This leaves us with one last possibly situation. More than two arguments and $a >= $b...

multi sub is-wave( 
                   'gte', 
                   Int $a, 
                   Int $b where { $a >= $b }, 
                   $c, 
                   *@r 
                 ) { 
    True && is-wave( 'lte', $b, $c, |@r ); 
}

So here we take 3 values where $a >= $b then we recurse into is-wave but now we pass lte, $b, $c and the rest of the list @r (this may be empty).

The code for the lte options are basically the same giving use this :

multi sub is-wave( 'lte', Int $a, Int $b where { $a <= $b } )
    { True }
multi sub is-wave( 'lte', Int $a, Int $b where { $a > $b } )
    { False }
multi sub is-wave( 'gte', Int $a, Int $b where { $a >= $b } )          
    { True }
multi sub is-wave( 'gte', Int $a, Int $b where { $a < $b } )           
    { False }
multi sub is-wave( 'gte', Int $a, Int $b where { $a < $b }, *@ )       
    { False }
multi sub is-wave( 'lte', Int $a, Int $b where { $a > $b }, *@ )       
    { False }
multi sub is-wave( 'gte', Int $a, Int $b where { $a >= $b }, $c, *@r )
    { True && is-wave( 'lte', $b, $c, |@r ); }
multi sub is-wave( 'lte', Int $a, Int $b where { $a <= $b }, $c, *@r )        
    { True && is-wave( 'gte', $b, $c, |@r ); }

There's probably a more elegant way to solve the problem without my brute force "Find every possible list and filter out the right ones" way but I do love that piece of code right there for it's simple elegance and the power that multi dispatch can bring to the table.

Perl Weekly Challenge In Raku : Week 50

Simon Proctor — Wed, 04 Mar 2020 09:52:24 +0000

Challenge 1

For some reason people have been giving me money for a number of years now to solve problems with computers. Which is nice. Often these problems involve ranges and whether they intersect (it's very often date ranges).

As such I've drawn a diagram like this very often on a bit of paper to dredge up the memory of how to do it :

   |---------| b
 1 2 3 4 5 6 7 8 9   == [ [1,3] , [2,7], [6,8] ]
 |---| a   |---| c

Here we have 3 sets of pairs. There's a simple rule to determine if they intersect. Given 2 pairs (call them x and y they intersect if):

x[0] <= y[1] && y[0] <= x[1]

And that's it, it's really that simple. Lets look at our example :

a and b ? a[0] <= b[1] && b[0] <= a[1] == 1 <= 7 && 2 <= 3 == True
b and c ? b[0] <= c[1] && c[0] <= b[1] == 2 <= 6 && 7 <= 8 == True
a and c ? a[0] <= c[1] && c[0] <= a[1] == 1 <= 8 && 6 <= 3 == False

With this knowledge the code to group unions is simple. Sort our list of lists, take the first item if it intersects with the second then expand it to cover the range of the two. Otherwise put it in the output and continue comparing the next one to the list... It's probably easer to read the code :

subset IntPair of Str where m!^ \d+ "," \d+ $!;

#| Given a list of Integer Pairs print the sorted list of pairs with intersections combined
multi sub MAIN (
    *@pairs where { $_.all ~~ IntPair } #= List of comma seperated integer pairs
) {
    my @working = @pairs.map(*.split(",")).sort( *[0] <=> *[0] );
    my @out;
    my $current = @working.shift;

    while ( @working ) {
        my $next = @working.shift;
        if ( $current[0] <= $next[1] && $current[1] >= $next[0] ) {
            $current = [ $current[0] < $next[0] ?? $current[0] !! $next[0],
                         $current[1] > $next[1] ?? $current[1] !! $next[1]  ]; 
        } else {
            @out.push( $current );
            $current = $next;
        }
    }
    @out.push( $current ).map( *.join(",") ).join(" ").say;
}

As normal I have wrapped this in a nice MAIN function to get some documentation and input checking.

A thought on my process

Personally when I do the challenge I try and complete it using just the language alone. Admittedly this is quite simple with Raku. In my day job I mostly work in Perl and will always reach for CPAN to see if someone has solved a problem before tackling it myself.

But I do the challenges because I want to explore the problem space and have a think about it. The thing is there is a Raku module (admittedly it's in a Beta state) that would help here Range::SetOps written by... oh me.

Ranges in Raku have a weird dual state, the represent a range between two points but if you look at them in the wrong way they will transform into a list of discrete entities.

For instance 5.5 ~~ 1..10 will return True because 5.5 is in the range 1..10 but 5.5 (elem) 1..10 will return False because the Range is coerced into a Set but making it a list of discrete items.

What Range::SetOps does is (again still in Beta, there's some flaws I really should finish it) overload the Set Operators when they handle Ranges or Sets that contain Ranges to return either Ranges or Sets of Ranges based on the operation.

For example without Range::SetOps loaded :

(2..7) ∪ (3..9) == set(2,3,4,5,6,7,8,9)

With Range::SetOps loaded :

(2..7) ∪ (3..9) == set(2..9)

With Range::SetOps our job is easier. Make our input lists into ranges. Find the Union Set of them then make them back into lists :

use Range::SetOps;
subset IntPair of Str where m!^ \d+ "," \d+ $!;

#| Given a list of Integer Pairs print the sorted list of pairs with intersections combined
multi sub MAIN (
    *@pairs where { $_.all ~~ IntPair } #= List of comma seperated integer pairs
) {
    ([∪] @pairs.map( { ($_[0]..$_[1]) } )).keys.map( { [$_.min,$_.max] } ).sort.map( *.join(",") ).join(" ").say;
}

Here we use the reduction meta operator [] to chain the ∪ intersection operations and end up with a Set of Ranges which we then turn back into a list of lists, prettify and print.

And yes I really should get round to finishing it, mostly it's handling Ranges with exceptions (^1..^10) for example.

Challenge 2

There's one thing about the description for this challenge I wasn't sure of which is whether you can have duplicate numbers. I checked and you can't. In which case my first intuitive thought for how to check if a number is Noble is simple enough.

Sort the list. Take the first number if it equals the length of the remaining list it's Noble. Repeat while you have a list.

#| Generate and display a random list of n integers (default 10) between 1 and max (default 30)
#| Then print the Noble Integers in the list
multi sub MAIN (
    UInt :n(:$number) = 10, #= Number of values to generate
    UInt :m(:$max) where { $max > $number } = 50  #= Maximum value (must be greater then $n)
) {
    my @list = (1..$max).pick($number);
    say "Generated List : {@list.join(",")}";
    MAIN( @list );
}

#| Given a list of Integers print the noble integers in the list
multi sub MAIN (
    *@values is copy where { $_.all ~~ UInt } #= Space seperated list of Intgers to check
) {
    @values.=sort;
    while ( @values ) {
        my $val = @values.shift;
        say $val if $val == @values.elems;
    }
}

Last night though my brain decided to have a think about the problem a bit more. The challenge asks can there be multiple noble numbers in a list?

So lets look at our options.

Can we have a list with 0 Noble numbers?

This is trivial to prove by example [3,4,5] is a simple example. But we also can glean a rule.

Given a sorted list of length L if the first number is greater than L-1 then the list has no Noble numbers.

Can we have a list with 1 Noble number?

Here we can work from the rule given before. If we have a sorted list of length L and it's first value is L-1 then it's a noble number.

As you can remove all the numbers before the first Noble number then many lists can have a noble number in.

[1,2,3,4,5,6,7,8,11,15] = 5 is Noble
[5,6,7,8,11,15] = 5 is Noble

Any amount of numbers (between 1 and 4) can go before the 5 and it will still be Noble.

There's a whole bunch of other stuff about for a given length of list what the range of possible Noble numbers are but I'm not interested in that right now.

Can we have a list with 2 Noble Numbers?

Assume we have a list with a Noble number in N this means there are N numbers following it in the list and 0 to N-1 numbers before it in the list.

Could N-1 be Noble? No.

There are N+1 (N and the N numbers following) after it. The same hold true for any number less than N.

Could N+1 be Noble? No.

There are N-1 number following it (as it has to come after N in the list and we know that there are N numbers in the following list). Again this holds true for all values greater than N.

So No. A given list will have either 0 or 1 Noble number.

Neat.

Perl Weekly Challenge - Week 49

Simon Proctor — Tue, 25 Feb 2020 12:03:44 +0000

So this weeks challenges are a bit of maths and a bit of computer science which is nice.

Challenge 1

Find the first multiple of a given number that is written using just 1's and 0's. This is one of these times where Raku's infinite lazy sequences just fit with the request.

First we make a sequence of the multiples of x :

($x,*+$x...*)

Then we get the first item in the list that fulfils our requirements :

($x,*+$x...*).first( { $_ ~~ m!^ <[10]>+ $! } )

(I started using ! as a regex delimiter years ago in Perl and carried on in Raku. It's really helpful when you're dealing with file paths and URL's as you don't need to escape the values.)

Finally we can wrap this in a MAIN sub, it's not needed but it's nice and can add some documentation which is always nice.

#| Find the first multiple of x made of only 1's and 0's
sub MAIN(
    UInt $x #= Number to look for multiple of
) {
    ( $x, * + $x...* ).hyper.first( { $_ ~~ m!^ <[10]>+ $! } ).say;
}

And there we go. Though... I would not advise running it for a multiple of 9. This is because if you add up all the digits in a multiple of 9 and keep doing so until you have 1 digit left you always get 9.

This would imply that the first multiple of 9 that has only 1's and 0's in it is 111111111 (which is 9 * 12345679). Working that out does take this code a while. another option is to use a lazy gather / take block like so :

my @seq = lazy gather {
    my $current = $x;
    loop {
        take $current;
        $current += $x;
    }
};

@seq.first( { $_ ~~ m!^ <[10]>+ $! } ).say;

This uses less memory but I still get bored waiting for it for calculate the first value for 9.

...

So writing this I had a brain spasm and realised I was approaching the problem in the wrong direction. Why not calculate the numbers made of 1's and 0's which can be easily done using binary and Raku's duck typing. This gives us the new code :

#| Find the first multiple of x made of only 1's and 0's
sub MAIN(
    UInt $x #= Number to look for multiple of
) {
    my @seq = lazy gather {
        my $current = 1;
        loop {
            take $current.base(2);
            $current++;
        }
    }

    @seq.first( * %% $x ).say;
}

This makes use of the fact that Int.base returns a Str but if you try and divide it then Raku auto casts it back to an Int in base 10. Job done and now you can get the value for 9 or 81 is super fast time. Awesome!

Challenge 2

So challenge 2 comes in two parts. Make an LRU Cache and demonstrate it's use. The "proper" Computer Science thing to do here would involve linked lists. But I generally find that trying to jam linked lists into high level languages (which under the hood use them) is generally more trouble than it's worth.

So I'm going with a simple idea, a hash and a list of keys. Each time I do something with the hash (getting or setting a value) I put key onto the list at the front :

[1,2,3] => [3,1,2,3]

reset it to the unique values :

[3,1,2]

then if it's too long pop the last value off the list.

Here's the class I made for that :

class Cache::LRU {

    has Int $!capacity where * > 0;
    has %!cache = {};
    has @!key-list = [];

    submethod BUILD ( :$capacity ) { $!capacity = $capacity }

    method !freshen ( $key ) {
        @!key-list.unshift($key).=unique;
        if @!key-list.elems > $!capacity {
            %!cache{@!key-list.pop}:delete;
        }
    }

    method current () {
        return @!key-list;
    }

    method get( $key ) {
        if %!cache{$key}:exists {
            self!freshen( $key );
            return %!cache{$key};
        }
        return Any;
    }

    method set( $key, $value ) {
        %!cache{$key} = $value;
        self!freshen( $key );
        return $value;
    }
}

Note that this code isn't thread safe. If you wanted to use it in the wild you probably want to pull in OO::Monitors to wrap the freshen, set and get methods. Also current only exists to demonstrate the cache.

Now to demonstrate it I decided to make a nice terminal interface like so :

#| Interactive LRU Cache example. Call with cache capacity
sub MAIN (
    Int $capacity where * > 0 #= Cache capacity (must be greater than zero)
) {
    my $cache = Cache::LRU.new( :$capacity );

    my $done = False;

    my multi sub action( "get", $key ) {
        say $cache.get($key) // "Not found";
    };
    my multi sub action( "set", $key, $value ) {
        $cache.set( $key, $value );
        say "Set $key to $value";
    };
    my multi sub action( "keys" ) {
        say "Current Keys : {$cache.current().join(",")}";
    };
    my multi sub action( "quit" ) {
        say "Bye";
        $done = True;
    };
    my multi sub action( *@ ) {
        say "I'm sorry Dave I don't know how to do that.";
        say "Valid options are :\n\tget \{key\}\n\tset \{key\} \{value\}\n\tkeys\n\tquit";
    };

    say "Welcome to the cache demo\nValid options are :\n\tget \{key\}\n\tset \{key\} \{value\}\n\tkeys\n\tquit";

    while ! $done {
        my @input = ( prompt "What would you like to do? " ).words;
        action( |@input );        
    }
}

So I setup a set of local multi dispatch sub's that have access to the Cache object and the loop flag then just loop round prompting for input.

Perl Weekly Challenge : Week 48

Simon Proctor — Mon, 17 Feb 2020 12:10:34 +0000

I've decided I'm going to try blogging about my attempts at the Perl Weekly Challenge which I've been doing since it started. Generally I do my challenge in Raku the language formally known as Perl6.

This weeks challenge has a couple of fun parts. If you've not tried it yet you might want to come back after you have.

Challenge 1

So I'd seen a video on this before it's called the Josephus Problem so I knew there was a mathematical solution to it.... but I couldn't remember it.

As is often the way I went a bit above and beyond and worked out a function to give the survivor number for any number of swordsmen. My thinking about it was simple. Get a list of number from 1 to 50, take the first two from the front. The first survives the second is dead. Put the survivor at the end of the list. Repeat until you have 1 survivor :

#| Calculate the survivor of the swordsmen suicide pact
multi sub MAIN(
    UInt $swords = 50, #= Number of swordsmen (default 50)
) {
    my @men = [1..$swords];
    while ( @men.elems > 1 ) {
        my ( $alive, $dead ) = @men.splice(0,2);
        @men.push($alive);
    }

    say "Survivor of $swords is number {@men[0]}";
}

With that I was able to run the test for lots of different value and worked out the mathematical solution. Given a number of swordsmen (s) we find p where p < s and p is a power of 2. Then the number of the survivor is the nth odd number where n = s - p.

For example for s = 50, p = 32 and n is the 18th odd number (indexed on 0) which is 37.

The code for this :

#| Calculate mathematically
multi sub MAIN(
    "math", 
    UInt $swords = 50, #= Number of swordsmen
) {
    my $low-power = (1,* * 2...*).first(* > $swords) div 2;
    say "Survivor of $swords is number {(1,3,5...*)[$swords - $low-power]}";
}

Couple of fun uses of Raku sequences one to generate the powers of 2 and the second to generate the list of odd numbers.

Challenge 2

For challenge 2 I initially worked on the theory I'll look at every date between 2020-01-01 and 2999-12-31 and look for palindromes. Turns out... that's a lot of days (357937 to be exact) and it take a while. Even when you use .hyper to thread the tests over multiple cores. But then I had a thought.

If I went through every month and day combination that's 12 x 31 (we'll worry about out of range values in a second) and that's only 372 to check. If we take the month and day and flip it to get a year if we can check it's valid and it's between our start and end dates.

#| Find the palendromic numbers (writen mmddyyy) between 2000-01-01 and 2999-01-01
sub MAIN() {
    my sub df( Date $d) {
        # Bleh American dates
        sprintf "%02d%02d%04d", .month, .day, .year given $d;
    }

    constant START = Date.new(2000,1,1,formatter => &df);
    constant END = Date.new(2999,12,31, formatter => &df);

    my @out;

    for (1..12) -> $month {
        for (1..31) -> $day {
            my $date;
            my $year = sprintf( "%02d%02d", $month, $day ).flip;
            try {
                $date = Date.new($year,$month,$day,formatter => &df);
            }
            next unless $date;
            next unless START <= $date <= END;
            @out.push($date);
        }
    }

    .say for @out.sort;
}

I hope that all makes sense. Feel free to drop a comment if you've got questions or thoughts.

My First Perl Conference

Simon Proctor — Mon, 20 Aug 2018 14:57:24 +0000

By Simon aged 40... something

I've been writing Perl code since I picked up a copy of Learning Perl in my local bookshop in 2001 or so. At the time I was working there, running the computer books department. My time at university had turned me off the idea of programming as a career, I found the theory of computer science to dry for me.

So reading about Perl, a language that felt like language rather than maths really appealed to me. A few months later I got a Junior Developer role and began my career as a developer.

Now we fast forward to 2018, I've been a Perl dev for 17 years working my way up to Senior and have yet to manage to get to a Perl Conference (European or American). As the 2018 one was planned for Glasgow and I have family in Scotland it was a no-brainer. I took a week off and put myself down as a speaker. Why? Because in the last few years I have got very interested in and impressed by Perl6. I have given a couple of talks at the London Perl Mongers about it and expanded on one at last years London Perl Workshop. I love the language and I want more people using it.

Things got interesting when the company that I work for Zoopla decided to sponsor the event and I went from the role of speaker to that of company spokes person. I had a lot more conversations about what it was like to work at Zoopla (awesome) than I was expecting to have.

Day 1

I arrived in Scotland on the Saturday before the conference but the first two days of workshops I skipped because I had other matters, involving my upcoming nuptials, to deal with. So I arrived on Wednesday not sure what to expect. I'd been to a couple of one day events over the years but not a full three day one.

What I was reminded of was gaming conventions, these I've done a lot of, and the general feeling of a group of like minded people in one place really came across. One major difference between the modern gaming convention and the conference was the male to female ratio was still skewing highly to the male side, that and the lack of a significant child presence. But other than that it felt very similar including the social aspects, meeting up with people who you often only see at these sort of events.

I attended a number of talks, some that I wasn't expecting because the schedule had got changed around and my calender wasn't up to date. Still interesting stuff on a variety of topics. One talk I found interesting was on The Perl Foundation and what it does. I may have ended up volunteering to help manage one of the sites, more on that if it happens. Then I saw Curtis "Ovid" Poe's talk on Rescuing a Legacy codebase (that could also be titled, how to talk to the business). And I got to meet him after and thank him for his excellent talk on Perl6 that had got me interested in it. At the end of the day was the Lightning talks which seemed fun and I decided to write one for Thursday.

Then it was off to Òran Mór for the meal. There was wonderful food (though too many people like the haggis pakora for my liking, I was hoping for thirds). I may have drunk a wee bit too much. But it was a nice relaxing evening.

Day 2

So Thursday was a bit blurry, I have felt worse but I didn't have enough sleep and was mostly existing on coffee and painkillers. Still I chatted to a bunch of people saw some interesting talks and wrote a little lightning talk.

Then it was time for my talk, I'd been preparing it for a while and had given it once internally to be able to get feedback and I felt I could manage to cover a lot about Perl6 Method Calls. I will admit to feeling some pressure as Larry Wall was sitting at the back of the room. But he's a very nice guy and I got to thank him for inventing the language that got me back into coding. So that was nice. We ended up at a lot of talks together as I mostly was on the unofficial Perl6 track.

As I say, the day was a bit of a blur, but I did give another Lightning Talk (about Perl6 operators) at the end of the day and then ended up talking to a few people about working at Zoopla and Perl6 so it was all good.

Day 3

By Friday I was having a combination of lack of sleep, way too much nervous energy and general buzz. I saw some great talks and there are more I didn't see. My current plan is as the talks get released on You Tube I'll link to them.

Thoughts

All in all I had a great time, though I'm going to need to learn to pace myself better. I'm not as young as I was and keeping up that level of enthusiasm has somewhat drained me.

Still I'd definitely recommend next years European Perl Conference in Riga (facebook link there, main site coming soon). And if you're in the UK the upcoming London Perl Workshop.

And if you're not into Perl (either version)? Well there's lots of other conferences. Find one for what you are interested in, and why not give a talk. It's easier than it looks. Find a thing you know about, preferably something you're passionate about, make some slides and practice some patter.

Also if you're not interested in Perl (especially Perl6) hang around. I plan on getting more things written here about it.