strace

Blown way through my time budget and there's a bunch of low hanging fruit (data dependencies in LCM, for example) but I'm late for work.

Co-authored-by: Smaug123 <patrick+github@patrickstevens.co.uk>
Reviewed-on: #8

.woodpecker/.all-checks-complete.yml

@@ -0,0 +1,10 @@
+steps:
+  echo:
+    image: alpine
+    commands:
+      - echo "All required checks complete"
+
+depends_on:
+  - build
+
+skip_clone: true

.woodpecker/.build.yml

@@ -0,0 +1,32 @@
+steps:
+  build:
+    image: nixos/nix
+    commands:
+      - echo 'experimental-features = flakes nix-command' >> /etc/nix/nix.conf
+
+      - "nix develop --command dotnet publish AdventOfCode2023.FSharp/AdventOfCode2023.FSharp/AdventOfCode2023.FSharp.fsproj --configuration Release -p:PublishAot=true || echo 'First publish failed'"
+      - "nix develop --command sh -c 'patchelf --set-interpreter $LINKER_PATH /tmp/dotnet-home/.nuget/packages/runtime.linux-x64.microsoft.dotnet.ilcompiler/8.0.0/tools/ilc'"
+      - "ls -al /tmp/dotnet-home/.nuget/packages/runtime.linux-x64.microsoft.dotnet.ilcompiler/8.0.0/tools/ilc"
+      - "chmod a+x /tmp/dotnet-home/.nuget/packages/runtime.linux-x64.microsoft.dotnet.ilcompiler/8.0.0/tools/ilc"
+      - "ls -al /tmp/dotnet-home/.nuget/packages/runtime.linux-x64.microsoft.dotnet.ilcompiler/8.0.0/tools/ilc"
+      - "whoami"
+      - "cp -r AdventOfCode2023.FSharp/AdventOfCode2023.FSharp/obj /tmp/obj"
+      - "nix develop --command sh -c 'ls -la $LINKER_PATH'"
+      - "nix develop --command sh -c 'strace /tmp/dotnet-home/.nuget/packages/runtime.linux-x64.microsoft.dotnet.ilcompiler/8.0.0/tools/ilc /tmp/obj/Release/net8.0/linux-x64/native/AdventOfCode2023.FSharp.ilc.rsp'"
+      - "nix develop --command dotnet publish AdventOfCode2023.FSharp/AdventOfCode2023.FSharp/AdventOfCode2023.FSharp.fsproj --configuration Release -p:PublishAot=true"
+      # Lint
+      - "nix flake check"
+      # Test
+      - nix develop --command dotnet test AdventOfCode2023.FSharp
+      - nix develop --command dotnet test AdventOfCode2023.FSharp --configuration Release
+      - nix develop --command alejandra --check .
+      - nix develop --command dotnet tool restore
+      - nix develop --command dotnet fantomas --check .
+      # TODO: if https://github.com/dotnet/sdk/issues/37295 ever gets fixed, remove the PublishAot=false
+      - "nix develop --command dotnet publish AdventOfCode2023.FSharp/AdventOfCode2023.FSharp/AdventOfCode2023.FSharp.fsproj --configuration Release -p:PublishAot=false -p:SelfContained=true"
+      - '$(find . -type f -name AdventOfCode2023.FSharp | grep Release | grep publish) "$(pwd)/AdventOfCode2023.FSharp/Test/samples"'
+
+    when:
+      - event: "push"
+        evaluate: 'CI_COMMIT_BRANCH == CI_REPO_DEFAULT_BRANCH'
+      - event: "pull_request"

AdventOfCode2023.FSharp/AdventOfCode2023.FSharp.Lib/AdventOfCode2023.FSharp.Lib.fsproj

@@ -7,10 +7,17 @@
 
     <ItemGroup>
         <Compile Include="Arr2D.fs" />
+        <Compile Include="ResizeArray.fs" />
         <Compile Include="EfficientString.fs" />
+        <Compile Include="Arithmetic.fs" />
         <Compile Include="Day1.fs" />
         <Compile Include="Day2.fs" />
         <Compile Include="Day3.fs" />
+        <Compile Include="Day4.fs" />
+        <Compile Include="Day5.fs" />
+        <Compile Include="Day6.fs" />
+        <Compile Include="Day7.fs" />
+        <Compile Include="Day8.fs" />
     </ItemGroup>
 
 </Project>

AdventOfCode2023.FSharp/AdventOfCode2023.FSharp.Lib/Arithmetic.fs

@@ -0,0 +1,67 @@
+namespace AdventOfCode2023
+
+[<RequireQualifiedAccess>]
+module Arithmetic =
+
+    [<Struct>]
+    type EuclidResult<'a> =
+        {
+            Hcf : 'a
+            A : 'a
+            B : 'a
+        }
+
+    /// Compute floor(sqrt(i)).
+    let inline sqrt (i : ^a) =
+        if i <= LanguagePrimitives.GenericOne then
+            i
+        else
+            let rec go start =
+                let next = start + LanguagePrimitives.GenericOne
+                let sqr = next * next
+
+                if sqr < LanguagePrimitives.GenericZero then
+                    // Overflow attempted, so the sqrt is between start and next
+                    start
+                elif i < sqr then
+                    start
+                elif i = sqr then
+                    next
+                else
+                    go next
+
+            go LanguagePrimitives.GenericOne
+
+    /// Find Hcf, A, B s.t. A * a + B * b = Hcf, and Hcf is the highest common factor of a and b.
+    let inline euclideanAlgorithm (a : ^a) (b : ^a) : EuclidResult< ^a > =
+        let rec go rMin1 r sMin1 s tMin1 t =
+            if r = LanguagePrimitives.GenericZero then
+                {
+                    Hcf = rMin1
+                    A = sMin1
+                    B = tMin1
+                }
+            else
+                let newQ = rMin1 / r
+                go r (rMin1 - newQ * r) s (sMin1 - newQ * s) t (tMin1 - newQ * t)
+
+        let maxA = max a b
+        let minB = min a b
+
+        let result =
+            go
+                maxA
+                minB
+                LanguagePrimitives.GenericOne
+                LanguagePrimitives.GenericZero
+                LanguagePrimitives.GenericZero
+                LanguagePrimitives.GenericOne
+
+        if a = maxA then
+            result
+        else
+            {
+                Hcf = result.Hcf
+                A = result.B
+                B = result.A
+            }

AdventOfCode2023.FSharp/AdventOfCode2023.FSharp.Lib/Day1.fs

@@ -5,21 +5,13 @@ open System
 [<RequireQualifiedAccess>]
 module Day1 =
 
-    let firstDigit (s : ReadOnlySpan<char>) =
-        let mutable pos = 0
-
-        while '0' > s.[pos] || s.[pos] > '9' do
-            pos <- pos + 1
-
+    let inline firstDigit (s : ReadOnlySpan<char>) =
+        let pos = s.IndexOfAnyInRange ('0', '9')
         byte s.[pos] - byte '0'
 
     // No surrogate pairs please!
-    let lastDigit (s : ReadOnlySpan<char>) =
-        let mutable pos = s.Length - 1
-
-        while '0' > s.[pos] || s.[pos] > '9' do
-            pos <- pos - 1
-
+    let inline lastDigit (s : ReadOnlySpan<char>) =
+        let pos = s.LastIndexOfAnyInRange ('0', '9')
         byte s.[pos] - byte '0'
 
     let part1 (s : string) =
@@ -35,35 +27,66 @@ module Day1 =
 
         total
 
-    let table =
-        [|
-            "one", 1uy
-            "two", 2uy
-            "three", 3uy
-            "four", 4uy
-            "five", 5uy
-            "six", 6uy
-            "seven", 7uy
-            "eight", 8uy
-            "nine", 9uy
-        |]
+    let isDigitSpelled (s : ReadOnlySpan<char>) (pos : int) (answer : byref<byte>) =
+        // Can't be bothered to write a jump-table compiler
+        if s.[pos] >= '0' && s.[pos] <= '9' then
+            answer <- byte s.[pos] - byte '0'
+        else if s.[pos] = 'o' then
+            if pos + 2 < s.Length && s.[pos + 1] = 'n' && s.[pos + 2] = 'e' then
+                answer <- 1uy
+        elif s.[pos] = 't' then
+            if pos + 2 < s.Length && s.[pos + 1] = 'w' && s.[pos + 2] = 'o' then
+                answer <- 2uy
+            elif
+                pos + 4 < s.Length
+                && s.[pos + 1] = 'h'
+                && s.[pos + 2] = 'r'
+                && s.[pos + 3] = 'e'
+                && s.[pos + 4] = 'e'
+            then
+                answer <- 3uy
+        elif s.[pos] = 'f' then
+            if pos + 3 < s.Length then
+                if s.[pos + 1] = 'o' && s.[pos + 2] = 'u' && s.[pos + 3] = 'r' then
+                    answer <- 4uy
+                elif s.[pos + 1] = 'i' && s.[pos + 2] = 'v' && s.[pos + 3] = 'e' then
+                    answer <- 5uy
+        elif s.[pos] = 's' then
+            if pos + 2 < s.Length && s.[pos + 1] = 'i' && s.[pos + 2] = 'x' then
+                answer <- 6uy
+            elif
+                pos + 4 < s.Length
+                && s.[pos + 1] = 'e'
+                && s.[pos + 2] = 'v'
+                && s.[pos + 3] = 'e'
+                && s.[pos + 4] = 'n'
+            then
+                answer <- 7uy
+        elif s.[pos] = 'e' then
+            if
+                pos + 4 < s.Length
+                && s.[pos + 1] = 'i'
+                && s.[pos + 2] = 'g'
+                && s.[pos + 3] = 'h'
+                && s.[pos + 4] = 't'
+            then
+                answer <- 8uy
+        elif s.[pos] = 'n' then
+            if
+                pos + 3 < s.Length
+                && s.[pos + 1] = 'i'
+                && s.[pos + 2] = 'n'
+                && s.[pos + 3] = 'e'
+            then
+                answer <- 9uy
 
     let firstDigitIncSpelled (s : ReadOnlySpan<char>) =
         let mutable pos = 0
         let mutable answer = 255uy
 
         while answer = 255uy do
-            if s.[pos] >= '0' && s.[pos] <= '9' then
-                answer <- byte s.[pos] - byte '0'
-            else
-                for i, value in table do
-                    if
-                        pos + i.Length < s.Length
-                        && MemoryExtensions.SequenceEqual (s.Slice (pos, i.Length), i)
-                    then
-                        answer <- value
-
-                pos <- pos + 1
+            isDigitSpelled s pos &answer
+            pos <- pos + 1
 
         answer
 
@@ -72,17 +95,8 @@ module Day1 =
         let mutable answer = 255uy
 
         while answer = 255uy do
-            if s.[pos] >= '0' && s.[pos] <= '9' then
-                answer <- byte s.[pos] - byte '0'
-            else
-                for i, value in table do
-                    if
-                        pos - i.Length + 1 >= 0
-                        && MemoryExtensions.SequenceEqual (s.Slice (pos - i.Length + 1, i.Length), i)
-                    then
-                        answer <- value
-
-                pos <- pos - 1
+            isDigitSpelled s pos &answer
+            pos <- pos - 1
 
         answer
 

AdventOfCode2023.FSharp/AdventOfCode2023.FSharp.Lib/Day2.fs

@@ -1,9 +1,12 @@
 namespace AdventOfCode2023
 
 open System
+open System.Globalization
 
 [<RequireQualifiedAccess>]
 module Day2 =
+    let inline parseInt (s : ReadOnlySpan<char>) : int =
+        Int32.Parse (s, NumberStyles.None, CultureInfo.InvariantCulture)
 
     let part1 (s : string) =
         use lines = StringSplitEnumerator.make '\n' s
@@ -18,20 +21,20 @@ module Day2 =
                 while isOk && words.MoveNext () do
                     match words.Current.[0] with
                     | 'b' ->
-                        if Int32.Parse prevWord > 14 then
+                        if parseInt prevWord > 14 then
                             isOk <- false
                     | 'r' ->
-                        if Int32.Parse prevWord > 12 then
+                        if parseInt prevWord > 12 then
                             isOk <- false
                     | 'g' ->
-                        if Int32.Parse prevWord > 13 then
+                        if parseInt prevWord > 13 then
                             isOk <- false
                     | _ -> ()
 
                     prevWord <- words.Current
 
                 if isOk then
-                    answer <- answer + Int32.Parse (line.Slice (5, line.IndexOf ':' - 5))
+                    answer <- answer + parseInt (line.Slice (5, line.IndexOf ':' - 5))
 
         answer
 
@@ -49,9 +52,9 @@ module Day2 =
 
                 while words.MoveNext () do
                     match words.Current.[0] with
-                    | 'b' -> blues <- max blues (Int32.Parse prevWord)
-                    | 'r' -> reds <- max reds (Int32.Parse prevWord)
-                    | 'g' -> greens <- max greens (Int32.Parse prevWord)
+                    | 'b' -> blues <- max blues (parseInt prevWord)
+                    | 'r' -> reds <- max reds (parseInt prevWord)
+                    | 'g' -> greens <- max greens (parseInt prevWord)
                     | _ -> ()
 
                     prevWord <- words.Current

AdventOfCode2023.FSharp/AdventOfCode2023.FSharp.Lib/Day3.fs

@@ -146,7 +146,7 @@ module Day3 =
 
         let mutable answer = 0
 
-        for KeyValue (_gearPos, gears) in gears do
+        for gears in gears.Values do
             if gears.Count = 2 then
                 answer <- answer + gears.[0] * gears.[1]
 

AdventOfCode2023.FSharp/AdventOfCode2023.FSharp.Lib/Day4.fs

@@ -0,0 +1,101 @@
+namespace AdventOfCode2023
+
+open System
+open System.Globalization
+
+[<RequireQualifiedAccess>]
+module Day4 =
+
+    let inline parseByte (chars : ReadOnlySpan<char>) : byte =
+        Byte.Parse (chars, NumberStyles.None, NumberFormatInfo.InvariantInfo)
+    //let mutable answer = 0uy
+    //for c in chars do
+    //    answer <- answer * 10uy + (byte c - 48uy)
+    //answer
+
+    let part1 (s : string) =
+        use lines = StringSplitEnumerator.make '\n' s
+        let mutable total = 0
+        let winningNumbers = ResizeArray<byte> ()
+
+        for line in lines do
+            if not (line.IsWhiteSpace ()) then
+                let mutable accumulatingWinning = true
+                winningNumbers.Clear ()
+                use mutable split = StringSplitEnumerator.make' ' ' line
+                StringSplitEnumerator.chomp "Card" &split
+
+                while split.Current.IsEmpty || split.Current.[split.Current.Length - 1] <> ':' do
+                    split.MoveNext () |> ignore
+
+                split.MoveNext () |> ignore
+
+                while accumulatingWinning do
+                    while split.Current.IsEmpty do
+                        split.MoveNext () |> ignore
+
+                    if split.Current.[0] = '|' then
+                        accumulatingWinning <- false
+                    else
+                        winningNumbers.Add (parseByte split.Current)
+                        split.MoveNext () |> ignore
+
+                let mutable answer = 0
+
+                while split.MoveNext () do
+                    if not split.Current.IsEmpty then
+                        let n = parseByte split.Current
+
+                        if winningNumbers.Contains n then
+                            answer <- answer + 1
+
+                if answer > 0 then
+                    total <- total + (1 <<< (answer - 1))
+
+        total
+
+    let part2 (s : string) =
+        use lines = StringSplitEnumerator.make '\n' s
+        let winningNumbers = ResizeArray<byte> ()
+        let winners = ResizeArray<int> ()
+
+        for line in lines do
+            if not (line.IsWhiteSpace ()) then
+                let mutable accumulatingWinning = true
+                winningNumbers.Clear ()
+                use mutable split = StringSplitEnumerator.make' ' ' line
+                StringSplitEnumerator.chomp "Card" &split
+
+                while split.Current.IsEmpty || split.Current.[split.Current.Length - 1] <> ':' do
+                    split.MoveNext () |> ignore
+
+                split.MoveNext () |> ignore
+
+                while accumulatingWinning do
+                    while split.Current.IsEmpty do
+                        split.MoveNext () |> ignore
+
+                    if split.Current.[0] = '|' then
+                        accumulatingWinning <- false
+                    else
+                        winningNumbers.Add (parseByte split.Current)
+                        split.MoveNext () |> ignore
+
+                let mutable answer = 0
+
+                while split.MoveNext () do
+                    if not split.Current.IsEmpty then
+                        let n = parseByte split.Current
+
+                        if winningNumbers.Contains n then
+                            answer <- answer + 1
+
+                winners.Add answer
+
+        let ans = Array.create winners.Count 1
+
+        for i = 0 to winners.Count - 1 do
+            for j = i + 1 to winners.[i] + i do
+                ans.[j] <- ans.[j] + ans.[i]
+
+        ans |> Array.sum

AdventOfCode2023.FSharp/AdventOfCode2023.FSharp.Lib/Day5.fs

@@ -0,0 +1,191 @@
+namespace AdventOfCode2023
+
+open System
+
+[<Struct>]
+type Range =
+    {
+        SourceStart : uint32
+        DestStart : uint32
+        Len : uint32
+    }
+
+[<RequireQualifiedAccess>]
+module Day5 =
+
+    let parse (s : string) =
+        use mutable lines = StringSplitEnumerator.make '\n' s
+        lines.MoveNext () |> ignore
+
+        let seeds =
+            use mutable line1 = StringSplitEnumerator.make' ' ' lines.Current
+            StringSplitEnumerator.chomp "seeds:" &line1
+            let result = ResizeArray ()
+
+            while line1.MoveNext () do
+                result.Add (UInt32.Parse line1.Current)
+
+            result.ToArray ()
+
+        lines.MoveNext () |> ignore
+
+        let mappings = ResizeArray ()
+
+        let mutable currentMapping = null
+
+        for line in lines do
+            if line.IsEmpty then
+                if not (isNull currentMapping) then
+                    mappings.Add currentMapping
+                    currentMapping <- null
+            else if isNull currentMapping then
+                currentMapping <- ResizeArray ()
+            else
+                use mutable line = StringSplitEnumerator.make' ' ' line
+                let destStart = StringSplitEnumerator.consumeU32 &line
+                let sourceStart = StringSplitEnumerator.consumeU32 &line
+                let rangeLen = StringSplitEnumerator.consumeU32 &line
+
+                {
+                    SourceStart = sourceStart
+                    DestStart = destStart
+                    Len = rangeLen
+                }
+                |> currentMapping.Add
+
+        seeds, mappings
+
+    let part1 (s : string) =
+        let seeds, mappings = parse s
+
+        let mutable best = UInt32.MaxValue
+
+        for seed in seeds do
+            let mutable remapped = seed
+
+            for map in mappings do
+                let mutable hasRemappedThisLayer = false
+
+                for interval in map do
+                    if not hasRemappedThisLayer then
+                        if
+                            interval.SourceStart <= remapped
+                            && remapped - interval.SourceStart < interval.Len
+                        then
+                            hasRemappedThisLayer <- true
+                            remapped <- remapped + (interval.DestStart - interval.SourceStart)
+
+            if remapped < best then
+                best <- remapped
+
+        best
+
+    // The input ranges are inclusive at both ends.
+    // Returns any range we didn't map.
+    let private split
+        (resultStarts : ResizeArray<uint32>)
+        (resultEnds : ResizeArray<uint32>)
+        start
+        finish
+        (rangeFromLayer : Range)
+        : (uint32 * uint32 * (uint32 * uint32) voption) voption
+        =
+        let low = rangeFromLayer.SourceStart
+        let high = rangeFromLayer.SourceStart + rangeFromLayer.Len - 1ul
+
+        if low <= start then
+            if finish <= high then
+                // low ... start .. finish .. high
+                // so the entire input range gets mapped down
+                resultStarts.Add (start + rangeFromLayer.DestStart - rangeFromLayer.SourceStart)
+                resultEnds.Add (finish + rangeFromLayer.DestStart - rangeFromLayer.SourceStart)
+
+                ValueNone
+            elif start <= high then
+                // low .. start .. high .. finish
+                // so start .. high gets mapped down
+                // and high + 1 .. finish stays where it is.
+                // high < finish is already guaranteed by previous if block.
+                resultStarts.Add (start + rangeFromLayer.DestStart - rangeFromLayer.SourceStart)
+                resultEnds.Add (high + rangeFromLayer.DestStart - rangeFromLayer.SourceStart)
+
+                ValueSome (high + 1ul, finish, ValueNone)
+            else
+                ValueSome (start, finish, ValueNone)
+        else if high <= finish then
+            // start .. low .. high .. finish
+            // so start .. low - 1 stays where it is
+            // low .. high gets mapped down
+            // and high + 1 .. finish stays where it is
+            resultStarts.Add (low + rangeFromLayer.DestStart - rangeFromLayer.SourceStart)
+            resultEnds.Add (high + rangeFromLayer.DestStart - rangeFromLayer.SourceStart)
+
+            ValueSome (start, low - 1ul, ValueSome (high + 1ul, finish))
+        elif low < finish then
+            // start .. low .. finish .. high
+            // so start .. low - 1 stays where it is
+            // and low .. finish gets mapped down
+            resultStarts.Add (low + rangeFromLayer.DestStart - rangeFromLayer.SourceStart)
+            resultEnds.Add (finish + rangeFromLayer.DestStart - rangeFromLayer.SourceStart)
+
+            ValueSome (start, low - 1ul, ValueNone)
+        else
+            ValueSome (start, finish, ValueNone)
+
+    let part2 (s : string) : uint32 =
+        let seeds, mappings = parse s
+
+        let mutable intervalStarts = ResizeArray ()
+        let mutable intervalEnds = ResizeArray ()
+
+        for i = 0 to (seeds.Length - 1) / 2 do
+            intervalStarts.Add seeds.[2 * i]
+            intervalEnds.Add (seeds.[2 * i + 1] + seeds.[2 * i] - 1ul)
+
+        let mutable nextIntervalStarts = ResizeArray ()
+        let mutable nextIntervalEnds = ResizeArray ()
+
+        for mapLayer in mappings do
+            let mutable i = 0
+
+            while i < intervalStarts.Count do
+                // split interval according to every map
+                let mutable allMoved = false
+                let mutable currentRange = 0
+
+                while not allMoved && currentRange < mapLayer.Count do
+                    let range = mapLayer.[currentRange]
+                    // range is e.g. 50 98 2, i.e. "98-99 goes to 50-51"
+                    match split nextIntervalStarts nextIntervalEnds intervalStarts.[i] intervalEnds.[i] range with
+                    | ValueNone -> allMoved <- true
+                    | ValueSome (start, finish, v) ->
+                        intervalStarts.[i] <- start
+                        intervalEnds.[i] <- finish
+
+                        match v with
+                        | ValueNone -> ()
+                        | ValueSome (start, finish) ->
+                            intervalStarts.Add start
+                            intervalEnds.Add finish
+
+                    currentRange <- currentRange + 1
+
+                if not allMoved then
+                    nextIntervalStarts.Add intervalStarts.[i]
+                    nextIntervalEnds.Add intervalEnds.[i]
+
+                i <- i + 1
+
+            let oldIntervals = intervalStarts
+            oldIntervals.Clear ()
+            intervalStarts <- nextIntervalStarts
+            nextIntervalStarts <- oldIntervals
+
+            let oldIntervals = intervalEnds
+            oldIntervals.Clear ()
+            intervalEnds <- nextIntervalEnds
+            nextIntervalEnds <- oldIntervals
+
+
+        // SIMD go brrr
+        System.Linq.Enumerable.Min intervalStarts

AdventOfCode2023.FSharp/AdventOfCode2023.FSharp.Lib/Day6.fs

@@ -0,0 +1,86 @@
+namespace AdventOfCode2023
+
+open System
+
+[<RequireQualifiedAccess>]
+module Day6 =
+
+    let parse (s : string) =
+        use mutable lines = StringSplitEnumerator.make '\n' s
+
+        let times =
+            lines.MoveNext () |> ignore
+            use mutable line = StringSplitEnumerator.make' ' ' lines.Current
+            StringSplitEnumerator.chomp "Time:" &line
+            line.MoveNext () |> ignore
+            let times = ResizeArray ()
+
+            while line.MoveNext () do
+                if not line.Current.IsEmpty then
+                    times.Add (UInt64.Parse line.Current)
+
+            times
+
+        let distance =
+            lines.MoveNext () |> ignore
+            use mutable line = StringSplitEnumerator.make' ' ' lines.Current
+            StringSplitEnumerator.chomp "Distance:" &line
+            line.MoveNext () |> ignore
+            let distance = ResizeArray ()
+
+            while line.MoveNext () do
+                if not line.Current.IsEmpty then
+                    distance.Add (UInt64.Parse line.Current)
+
+            distance
+
+        times, distance
+
+    let furthest (distance : uint64) (toBeat : uint64) =
+        // Count i in [1 .. distance - 1] such that (distance - i) * i > toBeat
+        // i.e. such that distance * i - i * i > toBeat
+        // -i^2 + distance * i - toBeat = 0 when:
+        // i = (distance +- sqrt(distance^2 - 4 * toBeat)) / 2
+        let distFloat = float distance
+        let inside = sqrt (distFloat * distFloat - 4.0 * float toBeat)
+        let limit1 = (distFloat + inside) / 2.0
+        let limit2 = (distFloat - sqrt (distFloat * distFloat - 4.0 * float toBeat)) / 2.0
+        // round limit2 up and limit1 down
+        let limit1 = uint64 (floor limit1)
+        let limit2 = uint64 (ceil limit2)
+        // cope with edge case of an exact square
+        if (uint64 inside) * (uint64 inside) = uint64 distance * uint64 distance - 4uL * uint64 toBeat then
+            limit1 - limit2 - 1uL
+        else
+            limit1 - limit2 + 1uL
+
+    let part1 (s : string) =
+        let times, distance = parse s
+        let mutable answer = 1uL
+
+        for i = 0 to times.Count - 1 do
+            let time = times.[i]
+            let distance = distance.[i]
+            let winners = furthest time distance
+            answer <- answer * winners
+
+        answer
+
+    let concat (digits : ResizeArray<uint64>) : uint64 =
+        let mutable answer = 0uL
+
+        for digit in digits do
+            let mutable power = 10uL
+
+            while digit >= power do
+                power <- power * 10uL
+
+            answer <- answer * power + digit
+
+        answer
+
+    let part2 (s : string) =
+        let times, distance = parse s
+        let concatTime = concat times
+        let concatDist = concat distance
+        furthest concatTime concatDist

AdventOfCode2023.FSharp/AdventOfCode2023.FSharp.Lib/Day7.fs

@@ -0,0 +1,215 @@
+namespace AdventOfCode2023
+
+open System
+open System.Globalization
+open AdventOfCode2023.ResizeArray
+
+type Hand =
+    | Five = 6
+    | Four = 5
+    | FullHouse = 4
+    | Three = 3
+    | TwoPairs = 2
+    | Pair = 1
+    | High = 0
+
+type HandContents =
+    {
+        First : byte
+        Second : byte
+        Third : byte
+        Fourth : byte
+        Fifth : byte
+    }
+
+[<RequireQualifiedAccess>]
+module Day7 =
+
+    [<Literal>]
+    let joker = 0uy
+
+    let inline toByte (adjustJoker : bool) (c : char) : byte =
+        if c <= '9' then byte c - byte '1'
+        elif c = 'T' then 9uy
+        elif c = 'J' then (if adjustJoker then joker else 10uy)
+        elif c = 'Q' then 11uy
+        elif c = 'K' then 12uy
+        elif c = 'A' then 13uy
+        else failwithf "could not parse: %c" c
+
+    let inline private updateState (tallies : ResizeArray<_>) newNum =
+        let mutable isAdded = false
+
+        for i = 0 to tallies.Count - 1 do
+            if fst tallies.[i] = newNum then
+                tallies.[i] <- (fst tallies.[i], snd tallies.[i] + 1)
+                isAdded <- true
+
+        if not isAdded then
+            tallies.Add (newNum, 1)
+
+    type RankedHand = uint32
+
+    [<Literal>]
+    let fourteen = 14ul
+
+    [<Literal>]
+    let fourteenFive = fourteen * fourteen * fourteen * fourteen * fourteen
+
+    [<Literal>]
+    let fourteenFour = fourteen * fourteen * fourteen * fourteen
+
+    [<Literal>]
+    let fourteenThree = fourteen * fourteen * fourteen
+
+    [<Literal>]
+    let fourteenTwo = fourteen * fourteen
+
+    let toInt (hand : Hand) (contents : HandContents) : RankedHand =
+        uint32 hand * fourteenFive
+        + uint32 contents.First * fourteenFour
+        + uint32 contents.Second * fourteenThree
+        + uint32 contents.Third * fourteenTwo
+        + uint32 contents.Fourth * fourteen
+        + uint32 contents.Fifth
+
+    let parseHand (tallyBuffer : ResizeArray<_>) (adjustJoker : bool) (s : ReadOnlySpan<char>) : RankedHand =
+        let contents =
+            {
+                First = toByte adjustJoker s.[0]
+                Second = toByte adjustJoker s.[1]
+                Third = toByte adjustJoker s.[2]
+                Fourth = toByte adjustJoker s.[3]
+                Fifth = toByte adjustJoker s.[4]
+            }
+
+        tallyBuffer.Clear ()
+        tallyBuffer.Add (contents.First, 1)
+        updateState tallyBuffer contents.Second
+        updateState tallyBuffer contents.Third
+        updateState tallyBuffer contents.Fourth
+        updateState tallyBuffer contents.Fifth
+
+        let jokerCount, jokerPos =
+            if not adjustJoker then
+                0, -1
+            else
+                let mutable jokerCount = 0
+                let mutable jokerPos = 0
+
+                while jokerPos < tallyBuffer.Count && jokerCount = 0 do
+                    let card, tally = tallyBuffer.[jokerPos]
+
+                    if card = joker then
+                        jokerCount <- tally
+                    else
+                        jokerPos <- jokerPos + 1
+
+                jokerCount, jokerPos
+
+        let hand =
+            if jokerCount > 0 then
+                match tallyBuffer.Count with
+                | 1 ->
+                    // Five jokers
+                    Hand.Five
+                | 2 ->
+                    // Jokers plus one other card type
+                    Hand.Five
+                | 3 ->
+                    // Jokers plus two other card types. Either full house, or four of a kind
+                    if jokerCount >= 2 then
+                        // JJABB or JJJAB
+                        Hand.Four
+                    else if
+                        // JAABB or JAAAB
+                        jokerPos <> 0
+                    then
+                        if snd tallyBuffer.[0] = 2 then
+                            Hand.FullHouse
+                        else
+                            Hand.Four
+                    else if snd tallyBuffer.[1] = 2 then
+                        Hand.FullHouse
+                    else
+                        Hand.Four
+                | 4 ->
+                    // Jokers plus three other card types, exactly one of which therefore is a two-of.
+                    Hand.Three
+                | 5 ->
+                    // Five different cards, one of which is a joker.
+                    Hand.Pair
+                | _ -> failwith "bad tallyBuffer"
+            elif tallyBuffer.Count = 1 then
+                Hand.Five
+            elif tallyBuffer.Count = 2 then
+                // AAAAB or AAABB
+                if snd tallyBuffer.[0] = 3 || snd tallyBuffer.[0] = 2 then
+                    Hand.FullHouse
+                else
+                    Hand.Four
+            elif tallyBuffer.Count = 3 then
+                // AAABC or AABBC
+                if snd tallyBuffer.[0] = 3 then Hand.Three
+                elif snd tallyBuffer.[0] = 2 then Hand.TwoPairs
+                elif snd tallyBuffer.[1] = 3 then Hand.Three
+                elif snd tallyBuffer.[1] = 2 then Hand.TwoPairs
+                else Hand.Three
+            elif tallyBuffer.Count = 4 then
+                Hand.Pair
+            else
+                Hand.High
+
+        toInt hand contents
+
+    type RankedHandAndBid = uint32
+
+    [<Literal>]
+    let bidSeparator = 1001ul
+
+    let inline toRankedHandAndBid (r : RankedHand) (bid : uint32) : RankedHandAndBid = bidSeparator * r + bid
+
+    let inline getBid (r : RankedHandAndBid) : uint32 = uint32 (r % bidSeparator)
+
+    let parse (adjustJoker : bool) (s : string) : ResizeArray<RankedHandAndBid> =
+        use mutable lines = StringSplitEnumerator.make '\n' s
+        let result = ResizeArray.create 4
+        let tallies = ResizeArray.create 5
+
+        while lines.MoveNext () do
+            if not lines.Current.IsEmpty then
+                use mutable line = StringSplitEnumerator.make' ' ' lines.Current
+                line.MoveNext () |> ignore
+                let rankedHand = parseHand tallies adjustJoker line.Current
+                line.MoveNext () |> ignore
+
+                let bid =
+                    UInt32.Parse (line.Current, NumberStyles.Integer, CultureInfo.InvariantCulture)
+
+                result.Add (toRankedHandAndBid rankedHand bid)
+
+        result
+
+    let part1 (s : string) =
+        let arr = parse false s
+
+        arr.Sort ()
+
+        let mutable answer = 0ul
+
+        for i = 0 to arr.Count - 1 do
+            answer <- answer + getBid arr.[i] * (uint32 i + 1ul)
+
+        answer
+
+    let part2 (s : string) =
+        let arr = parse true s
+
+        arr.Sort ()
+
+        let mutable answer = 0ul
+
+        for i = 0 to arr.Count - 1 do
+            answer <- answer + getBid arr.[i] * (uint32 i + 1ul)
+
+        answer

AdventOfCode2023.FSharp/AdventOfCode2023.FSharp.Lib/Day8.fs

@@ -0,0 +1,110 @@
+namespace AdventOfCode2023
+
+open System
+open System.Collections.Generic
+
+[<RequireQualifiedAccess>]
+module Day8 =
+
+    type Instructions =
+        {
+            /// "true" is 'R'
+            Steps : bool array
+
+            Nodes : Dictionary<string, string * string>
+        }
+
+    let parse (s : string) =
+        use mutable lines = StringSplitEnumerator.make '\n' s
+
+        lines.MoveNext () |> ignore
+
+        let stepsLine = lines.Current.TrimEnd ()
+        let steps = Array.zeroCreate stepsLine.Length
+
+        for i = 0 to stepsLine.Length - 1 do
+            steps.[i] <- (stepsLine.[i] = 'R')
+
+        let dict = Dictionary ()
+
+        while lines.MoveNext () do
+            if not lines.Current.IsEmpty then
+                use mutable line = StringSplitEnumerator.make' ' ' lines.Current
+                line.MoveNext () |> ignore
+                let key = line.Current.ToString ()
+                line.MoveNext () |> ignore
+                line.MoveNext () |> ignore
+                let v1 = line.Current.Slice(1, line.Current.Length - 2).ToString ()
+                line.MoveNext () |> ignore
+                let v2 = line.Current.Slice(0, line.Current.Length - 1).ToString ()
+                dict.[key] <- (v1, v2)
+
+        {
+            Steps = steps
+            Nodes = dict
+        }
+
+    let part1 (s : string) =
+        let data = parse s
+        let mutable i = 0
+        let mutable currentNode = "AAA"
+        let mutable answer = 0
+
+        while currentNode <> "ZZZ" do
+            let instruction = data.Nodes.[currentNode]
+
+            if data.Steps.[i] then
+                // "true" is R
+                currentNode <- snd instruction
+            else
+                currentNode <- fst instruction
+
+            i <- (i + 1) % data.Steps.Length
+            answer <- answer + 1
+
+        answer
+
+    let inline lcm (periods : ^T[]) =
+        let mutable lcm = periods.[0]
+        let mutable i = 1
+
+        while i < periods.Length do
+            let euclid = Arithmetic.euclideanAlgorithm lcm periods.[i]
+            lcm <- (lcm * periods.[i]) / euclid.Hcf
+            i <- i + 1
+
+        lcm
+
+    let part2 (s : string) =
+        let data = parse s
+
+        let startingNodes = ResizeArray ()
+
+        for key in data.Nodes.Keys do
+            if key.[key.Length - 1] = 'A' then
+                startingNodes.Add key
+
+        let periods =
+            Array.init
+                startingNodes.Count
+                (fun startNode ->
+                    let mutable i = 0
+                    let mutable currentNode = startingNodes.[startNode]
+                    let mutable answer = 0ul
+
+                    while currentNode.[currentNode.Length - 1] <> 'Z' do
+                        let instruction = data.Nodes.[currentNode]
+
+                        if data.Steps.[i] then
+                            // "true" is R
+                            currentNode <- snd instruction
+                        else
+                            currentNode <- fst instruction
+
+                        i <- (i + 1) % data.Steps.Length
+                        answer <- answer + 1ul
+
+                    uint64 answer
+                )
+
+        lcm periods

AdventOfCode2023.FSharp/AdventOfCode2023.FSharp.Lib/EfficientString.fs

@@ -95,3 +95,15 @@ module StringSplitEnumerator =
             failwith "expected an int, got nothing"
 
         Int32.Parse e.Current
+
+    let consumeU32 (e : byref<StringSplitEnumerator>) : uint32 =
+        if not (e.MoveNext ()) then
+            failwith "expected an int, got nothing"
+
+        UInt32.Parse e.Current
+
+    let consumeU64 (e : byref<StringSplitEnumerator>) : uint64 =
+        if not (e.MoveNext ()) then
+            failwith "expected an int, got nothing"
+
+        UInt64.Parse e.Current

AdventOfCode2023.FSharp/AdventOfCode2023.FSharp.Lib/ResizeArray.fs

@@ -0,0 +1,40 @@
+namespace AdventOfCode2023.ResizeArray
+
+open System
+
+type ResizeArray<'T> =
+    private
+        {
+            mutable Array : 'T array
+            mutable Length : int
+        }
+
+    member this.Count = this.Length
+    member this.Clear () = this.Length <- 0
+
+    member this.Add (t : 'T) =
+        if this.Length < this.Array.Length then
+            this.Array.[this.Length] <- t
+        else
+            let newLength = this.Length * 2
+            let newArray = Array.zeroCreate<'T> newLength
+            Array.blit this.Array 0 newArray 0 this.Length
+            newArray.[this.Length] <- t
+            this.Array <- newArray
+
+        this.Length <- this.Length + 1
+
+    member this.Item
+        with get (i : int) = this.Array.[i]
+        and set (i : int) (t : 'T) = this.Array.[i] <- t
+
+    member this.Sort () =
+        Span(this.Array).Slice(0, this.Count).Sort ()
+
+[<RequireQualifiedAccess>]
+module ResizeArray =
+    let create<'T> (capacity : int) =
+        {
+            Array = Array.zeroCreate<'T> capacity
+            Length = 0
+        }

AdventOfCode2023.FSharp/AdventOfCode2023.FSharp/Program.fs

@@ -23,19 +23,30 @@ module Program =
 
         let sw = Stopwatch.StartNew ()
 
+        Console.WriteLine "=====Day 1====="
+
         do
             sw.Restart ()
-            let input = Path.Combine (dir.FullName, "day1.txt") |> File.ReadAllText
+
+            let input =
+                try
+                    Path.Combine (dir.FullName, "day1part1.txt") |> File.ReadAllText
+                with :? FileNotFoundException ->
+                    Path.Combine (dir.FullName, "day1.txt") |> File.ReadAllText
+
             let part1 = Day1.part1 input
             sw.Stop ()
             Console.WriteLine (part1.ToString ())
             Console.Error.WriteLine ((1_000.0 * float sw.ElapsedTicks / float Stopwatch.Frequency).ToString () + "ms")
             sw.Restart ()
+            let input = Path.Combine (dir.FullName, "day1.txt") |> File.ReadAllText
             let part2 = Day1.part2 input
             sw.Stop ()
             Console.WriteLine (part2.ToString ())
             Console.Error.WriteLine ((1_000.0 * float sw.ElapsedTicks / float Stopwatch.Frequency).ToString () + "ms")
 
+        Console.WriteLine "=====Day 2====="
+
         do
             let input = Path.Combine (dir.FullName, "day2.txt") |> File.ReadAllText
             sw.Restart ()
@@ -49,6 +60,8 @@ module Program =
             Console.WriteLine (part2.ToString ())
             Console.Error.WriteLine ((1_000.0 * float sw.ElapsedTicks / float Stopwatch.Frequency).ToString () + "ms")
 
+        Console.WriteLine "=====Day 3====="
+
         do
             let input = Path.Combine (dir.FullName, "day3.txt") |> File.ReadAllBytes
 
@@ -85,7 +98,92 @@ module Program =
             Console.WriteLine (part2.ToString ())
             Console.Error.WriteLine ((1_000.0 * float sw.ElapsedTicks / float Stopwatch.Frequency).ToString () + "ms")
 
+        Console.WriteLine "=====Day 4====="
+
+        do
+            let input = Path.Combine (dir.FullName, "day4.txt") |> File.ReadAllText
+            sw.Restart ()
+            let part1 = Day4.part1 input
+            sw.Stop ()
+            Console.WriteLine (part1.ToString ())
+            Console.Error.WriteLine ((1_000.0 * float sw.ElapsedTicks / float Stopwatch.Frequency).ToString () + "ms")
+            sw.Restart ()
+            let part2 = Day4.part2 input
+            sw.Stop ()
+            Console.WriteLine (part2.ToString ())
+            Console.Error.WriteLine ((1_000.0 * float sw.ElapsedTicks / float Stopwatch.Frequency).ToString () + "ms")
+
+        Console.WriteLine "=====Day 5====="
+
+        do
+            let input = Path.Combine (dir.FullName, "day5.txt") |> File.ReadAllText
+            sw.Restart ()
+            let part1 = Day5.part1 input
+            sw.Stop ()
+            Console.WriteLine (part1.ToString ())
+            Console.Error.WriteLine ((1_000.0 * float sw.ElapsedTicks / float Stopwatch.Frequency).ToString () + "ms")
+            sw.Restart ()
+            let part2 = Day5.part2 input
+            sw.Stop ()
+            Console.WriteLine (part2.ToString ())
+            Console.Error.WriteLine ((1_000.0 * float sw.ElapsedTicks / float Stopwatch.Frequency).ToString () + "ms")
+
+        Console.WriteLine "=====Day 6====="
+
+        do
+            let input = Path.Combine (dir.FullName, "day6.txt") |> File.ReadAllText
+            sw.Restart ()
+            let part1 = Day6.part1 input
+            sw.Stop ()
+            Console.WriteLine (part1.ToString ())
+            Console.Error.WriteLine ((1_000.0 * float sw.ElapsedTicks / float Stopwatch.Frequency).ToString () + "ms")
+            sw.Restart ()
+            let part2 = Day6.part2 input
+            sw.Stop ()
+            Console.WriteLine (part2.ToString ())
+            Console.Error.WriteLine ((1_000.0 * float sw.ElapsedTicks / float Stopwatch.Frequency).ToString () + "ms")
+
+        Console.WriteLine "=====Day 7====="
+
+        do
+            let input = Path.Combine (dir.FullName, "day7.txt") |> File.ReadAllText
+            sw.Restart ()
+            let part1 = Day7.part1 input
+            sw.Stop ()
+            Console.WriteLine (part1.ToString ())
+            Console.Error.WriteLine ((1_000.0 * float sw.ElapsedTicks / float Stopwatch.Frequency).ToString () + "ms")
+            sw.Restart ()
+            let part2 = Day7.part2 input
+            sw.Stop ()
+            Console.WriteLine (part2.ToString ())
+            Console.Error.WriteLine ((1_000.0 * float sw.ElapsedTicks / float Stopwatch.Frequency).ToString () + "ms")
+
+        Console.WriteLine "=====Day 8====="
+
+        do
+            let input =
+                try
+                    Path.Combine (dir.FullName, "day8part1.txt") |> File.ReadAllText
+                with :? FileNotFoundException ->
+                    Path.Combine (dir.FullName, "day8.txt") |> File.ReadAllText
+
+            sw.Restart ()
+            let part1 = Day8.part1 input
+            sw.Stop ()
+            Console.WriteLine (part1.ToString ())
+            Console.Error.WriteLine ((1_000.0 * float sw.ElapsedTicks / float Stopwatch.Frequency).ToString () + "ms")
+            sw.Restart ()
+            let input = Path.Combine (dir.FullName, "day8.txt") |> File.ReadAllText
+            let part2 = Day8.part2 input
+            sw.Stop ()
+            Console.WriteLine (part2.ToString ())
+            Console.Error.WriteLine ((1_000.0 * float sw.ElapsedTicks / float Stopwatch.Frequency).ToString () + "ms")
+
         endToEnd.Stop ()
-        Console.Error.WriteLine ((1_000.0 * float endToEnd.ElapsedTicks / float Stopwatch.Frequency).ToString () + "ms total")
+
+        Console.Error.WriteLine (
+            (1_000.0 * float endToEnd.ElapsedTicks / float Stopwatch.Frequency).ToString ()
+            + "ms total"
+        )
 
         0

AdventOfCode2023.FSharp/Test/Test.fsproj

@@ -8,9 +8,25 @@
     </PropertyGroup>
 
     <ItemGroup>
+        <Compile Include="Util.fs" />
         <Compile Include="TestDay1.fs" />
         <Compile Include="TestDay2.fs" />
         <Compile Include="TestDay3.fs" />
+        <Compile Include="TestDay4.fs" />
+        <Compile Include="TestDay5.fs" />
+        <Compile Include="TestDay6.fs" />
+        <Compile Include="TestDay7.fs" />
+        <Compile Include="TestDay8.fs" />
+        <EmbeddedResource Include="samples\day1.txt" />
+        <EmbeddedResource Include="samples\day1part1.txt" />
+        <EmbeddedResource Include="samples\day2.txt" />
+        <EmbeddedResource Include="samples\day3.txt" />
+        <EmbeddedResource Include="samples\day4.txt" />
+        <EmbeddedResource Include="samples\day5.txt" />
+        <EmbeddedResource Include="samples\day6.txt" />
+        <EmbeddedResource Include="samples\day7.txt" />
+        <EmbeddedResource Include="samples\day8part1.txt" />
+        <EmbeddedResource Include="samples\day8.txt" />
     </ItemGroup>
 
     <ItemGroup>

AdventOfCode2023.FSharp/Test/TestDay1.fs

@@ -8,26 +8,13 @@ open System.IO
 [<TestFixture>]
 module TestDay1 =
 
-    let sample1 =
-        """1abc2
-pqr3stu8vwx
-a1b2c3d4e5f
-treb7uchet
-"""
+    let sample1 = Assembly.getEmbeddedResource typeof<Dummy>.Assembly "day1part1.txt"
 
     [<Test>]
     let part1Sample () =
         sample1 |> Day1.part1 |> shouldEqual 142
 
-    let sample2 =
-        """two1nine
-eightwothree
-abcone2threexyz
-xtwone3four
-4nineeightseven2
-zoneight234
-7pqrstsixteen
-"""
+    let sample2 = Assembly.getEmbeddedResource typeof<Dummy>.Assembly "day1.txt"
 
     [<Test>]
     let part2Sample () =
@@ -38,7 +25,9 @@ zoneight234
         let s =
             try
                 File.ReadAllText (Path.Combine (__SOURCE_DIRECTORY__, "../../inputs/day1.txt"))
-            with :? FileNotFoundException ->
+            with
+            | :? DirectoryNotFoundException
+            | :? FileNotFoundException ->
                 Assert.Inconclusive ()
                 failwith "unreachable"
 
@@ -49,7 +38,9 @@ zoneight234
         let s =
             try
                 File.ReadAllText (Path.Combine (__SOURCE_DIRECTORY__, "../../inputs/day1.txt"))
-            with :? FileNotFoundException ->
+            with
+            | :? DirectoryNotFoundException
+            | :? FileNotFoundException ->
                 Assert.Inconclusive ()
                 failwith "unreachable"
 

AdventOfCode2023.FSharp/Test/TestDay2.fs

@@ -8,13 +8,7 @@ open System.IO
 [<TestFixture>]
 module TestDay2 =
 
-    let sample =
-        """Game 1: 3 blue, 4 red; 1 red, 2 green, 6 blue; 2 green
-Game 2: 1 blue, 2 green; 3 green, 4 blue, 1 red; 1 green, 1 blue
-Game 3: 8 green, 6 blue, 20 red; 5 blue, 4 red, 13 green; 5 green, 1 red
-Game 4: 1 green, 3 red, 6 blue; 3 green, 6 red; 3 green, 15 blue, 14 red
-Game 5: 6 red, 1 blue, 3 green; 2 blue, 1 red, 2 green
-"""
+    let sample = Assembly.getEmbeddedResource typeof<Dummy>.Assembly "day2.txt"
 
     [<Test>]
     let part1Sample () = sample |> Day2.part1 |> shouldEqual 8
@@ -28,7 +22,9 @@ Game 5: 6 red, 1 blue, 3 green; 2 blue, 1 red, 2 green
         let s =
             try
                 File.ReadAllText (Path.Combine (__SOURCE_DIRECTORY__, "../../inputs/day2.txt"))
-            with :? FileNotFoundException ->
+            with
+            | :? DirectoryNotFoundException
+            | :? FileNotFoundException ->
                 Assert.Inconclusive ()
                 failwith "unreachable"
 
@@ -39,7 +35,9 @@ Game 5: 6 red, 1 blue, 3 green; 2 blue, 1 red, 2 green
         let s =
             try
                 File.ReadAllText (Path.Combine (__SOURCE_DIRECTORY__, "../../inputs/day2.txt"))
-            with :? FileNotFoundException ->
+            with
+            | :? DirectoryNotFoundException
+            | :? FileNotFoundException ->
                 Assert.Inconclusive ()
                 failwith "unreachable"
 

AdventOfCode2023.FSharp/Test/TestDay3.fs

@@ -13,18 +13,7 @@ open System.IO
 [<TestFixture>]
 module TestDay3 =
 
-    let sample =
-        """467..114..
-...*......
-..35..633.
-......#...
-617*......
-.....+.58.
-..592.....
-......755.
-...$.*....
-.664.598..
-"""
+    let sample = Assembly.getEmbeddedResource typeof<Dummy>.Assembly "day3.txt"
 
     [<Test>]
     let part1Sample () =
@@ -77,7 +66,9 @@ module TestDay3 =
         let bytes =
             try
                 File.ReadAllBytes (Path.Combine (__SOURCE_DIRECTORY__, "../../inputs/day3.txt"))
-            with :? FileNotFoundException ->
+            with
+            | :? DirectoryNotFoundException
+            | :? FileNotFoundException ->
                 Assert.Inconclusive ()
                 failwith "unreachable"
 
@@ -107,7 +98,9 @@ module TestDay3 =
         let bytes =
             try
                 File.ReadAllBytes (Path.Combine (__SOURCE_DIRECTORY__, "../../inputs/day3.txt"))
-            with :? FileNotFoundException ->
+            with
+            | :? DirectoryNotFoundException
+            | :? FileNotFoundException ->
                 Assert.Inconclusive ()
                 failwith "unreachable"
 

AdventOfCode2023.FSharp/Test/TestDay4.fs

@@ -0,0 +1,43 @@
+namespace AdventOfCode2023.Test
+
+open AdventOfCode2023
+open NUnit.Framework
+open FsUnitTyped
+open System.IO
+
+[<TestFixture>]
+module TestDay4 =
+
+    let sample = Assembly.getEmbeddedResource typeof<Dummy>.Assembly "day4.txt"
+
+    [<Test>]
+    let part1Sample () = sample |> Day4.part1 |> shouldEqual 13
+
+    [<Test>]
+    let part2Sample () = sample |> Day4.part2 |> shouldEqual 30
+
+    [<Test>]
+    let part1Actual () =
+        let s =
+            try
+                File.ReadAllText (Path.Combine (__SOURCE_DIRECTORY__, "../../inputs/day4.txt"))
+            with
+            | :? DirectoryNotFoundException
+            | :? FileNotFoundException ->
+                Assert.Inconclusive ()
+                failwith "unreachable"
+
+        Day4.part1 s |> shouldEqual 27454
+
+    [<Test>]
+    let part2Actual () =
+        let s =
+            try
+                File.ReadAllText (Path.Combine (__SOURCE_DIRECTORY__, "../../inputs/day4.txt"))
+            with
+            | :? DirectoryNotFoundException
+            | :? FileNotFoundException ->
+                Assert.Inconclusive ()
+                failwith "unreachable"
+
+        Day4.part2 s |> shouldEqual 6857330

AdventOfCode2023.FSharp/Test/TestDay5.fs

@@ -0,0 +1,46 @@
+namespace AdventOfCode2023.Test
+
+open System
+open AdventOfCode2023
+open NUnit.Framework
+open FsUnitTyped
+open System.IO
+
+[<TestFixture>]
+module TestDay5 =
+
+    let sample = Assembly.getEmbeddedResource typeof<Dummy>.Assembly "day5.txt"
+
+    [<Test>]
+    let part1Sample () =
+        sample |> Day5.part1 |> shouldEqual 35ul
+
+    [<Test>]
+    let part2Sample () =
+        sample |> Day5.part2 |> shouldEqual 46ul
+
+    [<Test>]
+    let part1Actual () =
+        let s =
+            try
+                File.ReadAllText (Path.Combine (__SOURCE_DIRECTORY__, "../../inputs/day5.txt"))
+            with
+            | :? DirectoryNotFoundException
+            | :? FileNotFoundException ->
+                Assert.Inconclusive ()
+                failwith "unreachable"
+
+        Day5.part1 s |> shouldEqual 806029445ul
+
+    [<Test>]
+    let part2Actual () =
+        let s =
+            try
+                File.ReadAllText (Path.Combine (__SOURCE_DIRECTORY__, "../../inputs/day5.txt"))
+            with
+            | :? DirectoryNotFoundException
+            | :? FileNotFoundException ->
+                Assert.Inconclusive ()
+                failwith "unreachable"
+
+        Day5.part2 s |> shouldEqual 59370572ul

AdventOfCode2023.FSharp/Test/TestDay6.fs

@@ -0,0 +1,46 @@
+namespace AdventOfCode2023.Test
+
+open System
+open AdventOfCode2023
+open NUnit.Framework
+open FsUnitTyped
+open System.IO
+
+[<TestFixture>]
+module TestDay6 =
+
+    let sample = Assembly.getEmbeddedResource typeof<Dummy>.Assembly "day6.txt"
+
+    [<Test>]
+    let part1Sample () =
+        sample |> Day6.part1 |> shouldEqual 288uL
+
+    [<Test>]
+    let part2Sample () =
+        sample |> Day6.part2 |> shouldEqual 71503uL
+
+    [<Test>]
+    let part1Actual () =
+        let s =
+            try
+                File.ReadAllText (Path.Combine (__SOURCE_DIRECTORY__, "../../inputs/day6.txt"))
+            with
+            | :? DirectoryNotFoundException
+            | :? FileNotFoundException ->
+                Assert.Inconclusive ()
+                failwith "unreachable"
+
+        Day6.part1 s |> shouldEqual 32076uL
+
+    [<Test>]
+    let part2Actual () =
+        let s =
+            try
+                File.ReadAllText (Path.Combine (__SOURCE_DIRECTORY__, "../../inputs/day6.txt"))
+            with
+            | :? DirectoryNotFoundException
+            | :? FileNotFoundException ->
+                Assert.Inconclusive ()
+                failwith "unreachable"
+
+        Day6.part2 s |> shouldEqual 34278221uL

AdventOfCode2023.FSharp/Test/TestDay7.fs

@@ -0,0 +1,46 @@
+namespace AdventOfCode2023.Test
+
+open System
+open AdventOfCode2023
+open NUnit.Framework
+open FsUnitTyped
+open System.IO
+
+[<TestFixture>]
+module TestDay7 =
+
+    let sample = Assembly.getEmbeddedResource typeof<Dummy>.Assembly "day7.txt"
+
+    [<Test>]
+    let part1Sample () =
+        sample |> Day7.part1 |> shouldEqual 6440ul
+
+    [<Test>]
+    let part2Sample () =
+        sample |> Day7.part2 |> shouldEqual 5905ul
+
+    [<Test>]
+    let part1Actual () =
+        let s =
+            try
+                File.ReadAllText (Path.Combine (__SOURCE_DIRECTORY__, "../../inputs/day7.txt"))
+            with
+            | :? DirectoryNotFoundException
+            | :? FileNotFoundException ->
+                Assert.Inconclusive ()
+                failwith "unreachable"
+
+        Day7.part1 s |> shouldEqual 250058342ul
+
+    [<Test>]
+    let part2Actual () =
+        let s =
+            try
+                File.ReadAllText (Path.Combine (__SOURCE_DIRECTORY__, "../../inputs/day7.txt"))
+            with
+            | :? DirectoryNotFoundException
+            | :? FileNotFoundException ->
+                Assert.Inconclusive ()
+                failwith "unreachable"
+
+        Day7.part2 s |> shouldEqual 250506580ul

AdventOfCode2023.FSharp/Test/TestDay8.fs

@@ -0,0 +1,57 @@
+namespace AdventOfCode2023.Test
+
+open AdventOfCode2023
+open NUnit.Framework
+open FsUnitTyped
+open System.IO
+
+[<TestFixture>]
+module TestDay8 =
+
+    [<Test>]
+    let part1Sample () =
+        Assembly.getEmbeddedResource typeof<Dummy>.Assembly "day8part1.txt"
+        |> Day8.part1
+        |> shouldEqual 2
+
+    [<Test>]
+    let part1Sample2 () =
+        """LLR
+
+AAA = (BBB, BBB)
+BBB = (AAA, ZZZ)
+ZZZ = (ZZZ, ZZZ)"""
+        |> Day8.part1
+        |> shouldEqual 6
+
+    [<Test>]
+    let part2Sample () =
+        Assembly.getEmbeddedResource typeof<Dummy>.Assembly "day8.txt"
+        |> Day8.part2
+        |> shouldEqual 6uL
+
+    [<Test>]
+    let part1Actual () =
+        let s =
+            try
+                File.ReadAllText (Path.Combine (__SOURCE_DIRECTORY__, "../../inputs/day8.txt"))
+            with
+            | :? DirectoryNotFoundException
+            | :? FileNotFoundException ->
+                Assert.Inconclusive ()
+                failwith "unreachable"
+
+        Day8.part1 s |> shouldEqual 19199
+
+    [<Test>]
+    let part2Actual () =
+        let s =
+            try
+                File.ReadAllText (Path.Combine (__SOURCE_DIRECTORY__, "../../inputs/day8.txt"))
+            with
+            | :? DirectoryNotFoundException
+            | :? FileNotFoundException ->
+                Assert.Inconclusive ()
+                failwith "unreachable"
+
+        Day8.part2 s |> shouldEqual 13663968099527uL

AdventOfCode2023.FSharp/Test/Util.fs

@@ -0,0 +1,22 @@
+namespace AdventOfCode2023.Test
+
+open System.IO
+open System.Reflection
+
+type Dummy =
+    class
+    end
+
+[<RequireQualifiedAccess>]
+module Assembly =
+    let getEmbeddedResource (assembly : Assembly) (name : string) : string =
+        let names = assembly.GetManifestResourceNames ()
+        let names = names |> Seq.filter (fun s -> s.EndsWith name)
+
+        use s =
+            names
+            |> Seq.exactlyOne
+            |> assembly.GetManifestResourceStream
+            |> fun s -> new StreamReader (s)
+
+        s.ReadToEnd ()

AdventOfCode2023.FSharp/Test/samples/day1.txt

@@ -0,0 +1,7 @@
+two1nine
+eightwothree
+abcone2threexyz
+xtwone3four
+4nineeightseven2
+zoneight234
+7pqrstsixteen

AdventOfCode2023.FSharp/Test/samples/day1part1.txt

@@ -0,0 +1,4 @@
+1abc2
+pqr3stu8vwx
+a1b2c3d4e5f
+treb7uchet

AdventOfCode2023.FSharp/Test/samples/day2.txt

@@ -0,0 +1,5 @@
+Game 1: 3 blue, 4 red; 1 red, 2 green, 6 blue; 2 green
+Game 2: 1 blue, 2 green; 3 green, 4 blue, 1 red; 1 green, 1 blue
+Game 3: 8 green, 6 blue, 20 red; 5 blue, 4 red, 13 green; 5 green, 1 red
+Game 4: 1 green, 3 red, 6 blue; 3 green, 6 red; 3 green, 15 blue, 14 red
+Game 5: 6 red, 1 blue, 3 green; 2 blue, 1 red, 2 green

AdventOfCode2023.FSharp/Test/samples/day3.txt

@@ -0,0 +1,10 @@
+467..114..
+...*......
+..35..633.
+......#...
+617*......
+.....+.58.
+..592.....
+......755.
+...$.*....
+.664.598..

AdventOfCode2023.FSharp/Test/samples/day4.txt

@@ -0,0 +1,6 @@
+Card 1: 41 48 83 86 17 | 83 86  6 31 17  9 48 53
+Card 2: 13 32 20 16 61 | 61 30 68 82 17 32 24 19
+Card 3:  1 21 53 59 44 | 69 82 63 72 16 21 14  1
+Card 4: 41 92 73 84 69 | 59 84 76 51 58  5 54 83
+Card 5: 87 83 26 28 32 | 88 30 70 12 93 22 82 36
+Card 6: 31 18 13 56 72 | 74 77 10 23 35 67 36 11

AdventOfCode2023.FSharp/Test/samples/day5.txt

@@ -0,0 +1,33 @@
+seeds: 79 14 55 13
+
+seed-to-soil map:
+50 98 2
+52 50 48
+
+soil-to-fertilizer map:
+0 15 37
+37 52 2
+39 0 15
+
+fertilizer-to-water map:
+49 53 8
+0 11 42
+42 0 7
+57 7 4
+
+water-to-light map:
+88 18 7
+18 25 70
+
+light-to-temperature map:
+45 77 23
+81 45 19
+68 64 13
+
+temperature-to-humidity map:
+0 69 1
+1 0 69
+
+humidity-to-location map:
+60 56 37
+56 93 4

AdventOfCode2023.FSharp/Test/samples/day6.txt

@@ -0,0 +1,2 @@
+Time:      7  15   30
+Distance:  9  40  200

AdventOfCode2023.FSharp/Test/samples/day7.txt

@@ -0,0 +1,5 @@
+32T3K 765
+T55J5 684
+KK677 28
+KTJJT 220
+QQQJA 483

AdventOfCode2023.FSharp/Test/samples/day8.txt

@@ -0,0 +1,10 @@
+LR
+
+11A = (11B, XXX)
+11B = (XXX, 11Z)
+11Z = (11B, XXX)
+22A = (22B, XXX)
+22B = (22C, 22C)
+22C = (22Z, 22Z)
+22Z = (22B, 22B)
+XXX = (XXX, XXX)

AdventOfCode2023.FSharp/Test/samples/day8part1.txt

@@ -0,0 +1,9 @@
+RL
+
+AAA = (BBB, CCC)
+BBB = (DDD, EEE)
+CCC = (ZZZ, GGG)
+DDD = (DDD, DDD)
+EEE = (EEE, EEE)
+GGG = (GGG, GGG)
+ZZZ = (ZZZ, ZZZ)

flake.lock

@@ -18,6 +18,26 @@
         "type": "github"
       }
     },
+    "nix-ld": {
+      "inputs": {
+        "nixpkgs": [
+          "nixpkgs"
+        ]
+      },
+      "locked": {
+        "lastModified": 1701153607,
+        "narHash": "sha256-h+odOVyiGmEERMECoFOj5P7FPiMR8IPRzroFA4sKivg=",
+        "owner": "Mic92",
+        "repo": "nix-ld",
+        "rev": "bf5aa84a713c31d95b4307e442e966d6c7fd7ae7",
+        "type": "github"
+      },
+      "original": {
+        "owner": "Mic92",
+        "repo": "nix-ld",
+        "type": "github"
+      }
+    },
     "nixpkgs": {
       "locked": {
         "lastModified": 1701253981,
@@ -37,6 +57,7 @@
     "root": {
       "inputs": {
         "flake-utils": "flake-utils",
+        "nix-ld": "nix-ld",
         "nixpkgs": "nixpkgs"
       }
     },

flake.nix

@@ -1,26 +1,54 @@
 {
-    description = "Advent of Code 2023";
-    inputs = {
-        flake-utils.url = "github:numtide/flake-utils";
-        nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
+  description = "Advent of Code 2023";
+  inputs = {
+    flake-utils.url = "github:numtide/flake-utils";
+    nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
+    nix-ld = {
+      url = "github:Mic92/nix-ld";
+      inputs.nixpkgs.follows = "nixpkgs";
     };
+  };
 
-    outputs = {
-        self,
-        nixpkgs,
-        flake-utils,
-    }: flake-utils.lib.eachDefaultSystem (system:
-    let pkgs = nixpkgs.legacyPackages.${system}; in
-    {
-        devShells = { default = pkgs.mkShell {
-          buildInputs = with pkgs; [
-            (with dotnetCorePackages;
-              combinePackages [
-                dotnet-sdk_8
-                dotnetPackages.Nuget
-              ])
-          ] ++ [pkgs.swift darwin.apple_sdk.frameworks.Foundation darwin.apple_sdk.frameworks.CryptoKit darwin.apple_sdk.frameworks.GSS pkgs.zlib pkgs.zlib.dev pkgs.openssl pkgs.icu];
-        };};
-    }
+  outputs = {
+    self,
+    nixpkgs,
+    flake-utils,
+    nix-ld,
+  }:
+    flake-utils.lib.eachDefaultSystem (
+      system: let
+        pkgs = nixpkgs.legacyPackages.${system};
+      in
+        # Conditionally include Swift and Apple SDK for Darwin systems
+        let
+          darwinDeps =
+            if system == "x86_64-darwin" || system == "aarch64-darwin"
+            then [
+              pkgs.swift
+              pkgs.darwin.apple_sdk.frameworks.Foundation
+              pkgs.darwin.apple_sdk.frameworks.CryptoKit
+              pkgs.darwin.apple_sdk.frameworks.GSS
+            ]
+            else [];
+        in let
+          deps = darwinDeps ++ [pkgs.zlib pkgs.zlib.dev pkgs.openssl pkgs.icu];
+        in {
+          devShells = {
+            default = pkgs.mkShell {
+              HOME = "/tmp/dotnet-home";
+              NUGET_PACKAGES = "/tmp/dotnet-home/.nuget/packages";
+              LINKER_PATH = "${pkgs.stdenv.cc}/nix-support/dynamic-linker";
+              buildInputs = with pkgs;
+                [
+                  (with dotnetCorePackages;
+                    combinePackages [
+                      dotnet-sdk_8
+                      dotnetPackages.Nuget
+                    ])
+                ]
+                ++ [pkgs.alejandra pkgs.patchelf pkgs.strace];
+            };
+          };
+        }
     );
 }