Monthly Archives: December 2016

Advent of Code 2016: Things I’ve Learned

I’ve been engaged in the Advent of Code 2016. Attempting to improve upon my solutions from 2015. I have improved a lot since last year. However, as of Day 8 there are some things that I have notably learned. Well, some things I’ve forgotten and learned again. Here are the highlights so far:

Seq.chunkBySize

This was added in F# 4.0. This function allows you to partition your collection into arrays of a size of your choosing.
For example:

[1 .. 6] |> Seq.chunkBySize 2;;  // seq [[|1; 2|]; [|3; 4|]; [|5; 6|]]
[1 .. 6] |> Seq.chunkBySize 3;;  // seq [[|1; 2; 3|]; [|4; 5; 6|]]

There is a caveat, if the number of items in the collection is not equally divisible by the chunk size, the last array will have fewer items.

[1 .. 6] |> Seq.chunkBySize 5;;  // seq [[|1; 2; 3; 4; 5|]; [|6|]]

Slicing

This one I seem to forget is available. I always start with a for or a skip |> take and then I remember. It can make your code a lot easier to read.

Spoilers for day 8

I am using a mutable 2D array for day 8. There was a similar problem last year and I chose to go fully immutable and got destroyed by Garbage Collection. Mutability we go! The problem called for shifting pixels (which wrap) on a display. I decided to get the current row of pixels starting at origin (I define the origin as being the length of the array minus the amount we are shifting). I then could apply the shifted row to the mutable 2D array.

My initial implementation:

member this.RotateRow (y,shift) =
  let origin = width - shift
  seq { for i in {origin .. width - 1} do
          yield display.[i, y]
        for i in {0 .. origin - 1} do
          yield display.[i, y] } 
  |> applyShift

It’s not terribly bad. We get the items from shift origin to the end of the array followed by items from the start of the array to origin. We can do better with slicing.

Slicing an array or list is a matter of using the indexer after the label.

let l1 = [1 .. 100];;
l1.[6 .. 10];; // [7; 8; 9; 10; 11]
l1.[7 .. 11];; 
l1.[.. 10];;   // [1; 2; 3; 4; 5; 6; 7; 8; 9; 10; 11]
l1.[95 ..];;   // [96; 97; 98; 99; 100]

Did you notice I said indexer? Yes, slice takes the items via their position in the collection. This is something you will need to be aware of. If you want the first ten items using slice you would use [..9], as the tenth item is in position nine.

Updating my original solution using slices instead of for constructs has made my solution more concise and readable.

member this.RotateRow (y,shift) =
  let origin = width - shift
  seq { yield display.[origin .., y]
        yield display.[.. origin - 1, y] } 
  |> applyShift

By using slices I removed the need to calculate the end of the array. This eliminated the chance of an off by one error. <insert bad off by 2 joke here>

Seq.windowed

Seq.windowed is handy when you need to look for specific patterns in a collection. This function works by taking a collection and creating a sliding window of arrays with the length you specify.

Some examples of course:

let l1 = [1 .. 5];;
l1 |> Seq.windowed 2;; // seq [[|1; 2|]; [|2; 3|]; [|3; 4|]; [|4; 5|]
l1 |> Seq.windowed 3;; // seq [[|1; 2; 3|]; [|2; 3; 4|]; [|3; 4; 5|]
l1 |> Seq.windowed 4;; // seq [[|1; 2; 3; 4|]; [|2; 3; 4; 5|]]
l1 |> Seq.windowed 6;; // seq [] 

If you try to get windows larger than the size of the collection, you end up with an empty collection.

Seq.chunkBySize, slicing, and Seq.windowed are my three most notable take aways from the first 8 days of Advent of Code 2016.