0 Comments

I’ve set up a GitHub repository for my F# solutions to Advent of Code this year, and although this year I suspect I won’t have enough time to blog about every day’s solution, I did attempt the first day’s problem.

As usual, the first part is simply parsing the problem input. For this problem, there was a string of directions like this: “L2, R3” which means turn left, go forward two blocks, turn right, go forward three blocks.

I needed to turn this into a sequence of “instructions”. Initially I used string splitting, and my instruction type encapsulated the change of direction and the number of blocks to move. But as it turned out, part 2 of the problem is more easily solved if there is a separate “turn” instruction, and instead of a “move forward n blocks” command, it should repeat the “move forward 1 block” command n times.

So by using a bit of regular expressions and a Seq.collect to expand the move commands, we can get them into a sequence of Instruction types like this:

open System.Text.RegularExpressions
type Turn = Right | Left
type Instruction = Turn of Turn | Move
let input = System.IO.File.ReadAllText (__SOURCE_DIRECTORY__ + "\\input.txt")
let instructions = Regex.Matches(input, "([LR])|(\\d+)") 
                    |> Seq.cast<Match>
                    |> Seq.map (fun m -> m.Value)
                    |> Seq.collect (function | "L" -> [Turn Left] | "R" -> [Turn Right] | n -> [for _ in 1..int(n) -> Move])

Now the state we need to maintain as we apply these commands is what our current position is, what direction we are facing, and (for part b of the problem), all the places we have visited so far.

This can be done by using a tuple for the current position, a vector indicating the direction we are facing (which eliminates some clumsy match statements from my original solution which created a discriminated union of North | West | South | East), and an immutable set of all locations we have visited so far. Here’s my State type and the starting state:

type State = { pos: int*int; facing: int*int; visited: Set<int*int> }
let startState = { pos = (0,0); facing = (0,-1); visited = Set.empty } 

Now we need a move function that takes an instruction and a current state, and applies it, creating a new state. The instructions are either turn, or move one step forwards. So I created a couple of helper functions – one to rotate the direction, and one to add two vectors, and used them to implement the move function:

let rotate (x,y) = function | Right -> (y*(-1),x) | Left -> (y,x*(-1)) 
let move state instruction =
    match instruction with 
    | Turn direction ->
        { state with facing = rotate state.facing direction }
    | Move ->
        let addv (x,y) (i,j) = (x+i,y+j)
        { state with pos = addv state.pos state.facing; visited = Set.add state.pos state.visited  }

Once we can apply one instruction, it is trivial to apply all the instructions with a fold, and get the finishing state from which we only need the current position to solve part a:

let endState = instructions |> Seq.fold move startState
let getDistance (x,y) = abs(x) + abs(y)
printfn "Part a: Distance from home is %d" (getDistance endState.pos)

Part b required us to remember all the places we had been (which is why we maintain the visited set in the state object), and identify the first place we visit twice. We can achieve this by using a scan, which produces a sequence of states as we apply each instruction. That means we can use find to iterate through until we find the first one where the current position is in the list of already visited places.

let visitedTwice = instructions 
                    |> Seq.scan move startState
                    |> Seq.find (fun f -> f.visited.Contains(f.pos))
                    
printfn "Part b: Distance from home is %d" (getDistance visitedTwice.pos)

You can see the full code here, and as always I welcome ideas about how my F# can be improved.

One of the interesting things about solving this challenge in F# was the realisation that I would have been able to solve it much quicker with procedural instead of functional code. I’d simply create a for loop to go through each instruction, mutating a current position and facing direction variable and adding positions to an already visited list.

By contrast, the functional solution was harder to refactor from part a to part b, since the fold function I’d used wasn’t appropriate any more, and I had to significantly change my code to suit it to solving both halves of the problem.

So although I believe a functional paradigm has a lot of benefits over procedural, this challenge highlights that my brain is still wired to think procedurally, and it will be a while yet before I find the functional approach comes more naturally.

Vote on HN
comments powered by Disqus