Day 9

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

@@ -1,24 +1,25 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
-    <PropertyGroup>
-        <TargetFramework>net8.0</TargetFramework>
-        <GenerateDocumentationFile>true</GenerateDocumentationFile>
-    </PropertyGroup>
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <GenerateDocumentationFile>true</GenerateDocumentationFile>
+  </PropertyGroup>
 
-    <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" />
-        <Compile Include="Day9.fs" />
-    </ItemGroup>
+  <ItemGroup>
+    <Compile Include="Arr2D.fs"/>
+    <Compile Include="ResizeArray.fs"/>
+    <Compile Include="EfficientString.fs"/>
+    <Compile Include="Arithmetic.fs"/>
+    <Compile Include="Rational.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"/>
+    <Compile Include="Day9.fs"/>
+  </ItemGroup>
 
 </Project>

AdventOfCode2023.FSharp/AdventOfCode2023.FSharp.Lib/Day9.fs

@@ -1,37 +1,55 @@
 namespace AdventOfCode2023
 
 open System
-open System.Collections.Generic
 
 [<RequireQualifiedAccess>]
 module Day9 =
 
-    let parse (s : string) =
-        use mutable lines = StringSplitEnumerator.make '\n' s
+    let extrapolate (isStart : bool) (arr : ResizeArray<int64>) =
+        let mutable answer = 0L
+        let pos = if isStart then -1L else int64 arr.Count
 
-        lines.MoveNext () |> ignore
+        for i = 0 to arr.Count - 1 do
+            let mutable product = Rational.ofInt arr.[i]
 
-        let stepsLine = lines.Current.TrimEnd ()
-        let steps = Array.zeroCreate stepsLine.Length
+            for j = 0 to arr.Count - 1 do
+                if j <> i then
+                    product <- product * Rational.make (pos - int64 j) (int64 i - int64 j)
 
-        for i = 0 to stepsLine.Length - 1 do
-            steps.[i] <- (stepsLine.[i] = 'R')
+            answer <- answer + Rational.assertIntegral product
 
-        let dict = Dictionary ()
-
-        while lines.MoveNext () do
-            if not lines.Current.IsEmpty then
-                use mutable line = StringSplitEnumerator.make' ' ' lines.Current
-                line.MoveNext () |> ignore
-        {
-            Steps = steps
-            Nodes = dict
-        }
+        answer
 
     let part1 (s : string) =
-        let data = parse s
+        use s = StringSplitEnumerator.make '\n' s
+        let mutable answer = 0L
+        let arr = ResizeArray ()
+
+        for line in s do
+            arr.Clear ()
+            use line = StringSplitEnumerator.make' ' ' line
+
+            for number in line do
+                let number = Int64.Parse number
+                arr.Add number
+
+            answer <- answer + extrapolate false arr
+
         answer
 
     let part2 (s : string) =
-        let data = parse s
-        0
+        use s = StringSplitEnumerator.make '\n' s
+        let mutable answer = 0L
+        let arr = ResizeArray ()
+
+        for line in s do
+            arr.Clear ()
+            use line = StringSplitEnumerator.make' ' ' line
+
+            for number in line do
+                let number = Int64.Parse number
+                arr.Add number
+
+            answer <- answer + extrapolate true arr
+
+        answer

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

@@ -1,7 +1,6 @@
 namespace AdventOfCode2023
 
 open System
-open System.Globalization
 open System.Runtime.CompilerServices
 
 type EfficientString = System.ReadOnlySpan<char>

AdventOfCode2023.FSharp/AdventOfCode2023.FSharp.Lib/Rational.fs

@@ -0,0 +1,82 @@
+namespace AdventOfCode2023
+
+[<Struct>]
+type Rational<'a
+    when 'a : (static member (+) : 'a * 'a -> 'a)
+    and 'a : (static member (*) : 'a * 'a -> 'a)
+    and 'a : (static member (/) : 'a * 'a -> 'a)
+    and 'a : (static member (-) : 'a * 'a -> 'a)
+    and 'a : (static member Zero : 'a)
+    and 'a : (static member One : 'a)
+    and 'a : comparison> =
+    {
+        Numerator : 'a
+        Denominator : 'a
+    }
+
+    static member inline (+) (a : Rational<'a>, b : Rational<'a>) =
+        let numerator = a.Numerator * b.Denominator + b.Numerator * a.Denominator
+        let denominator = a.Denominator * b.Denominator
+        let hcf = (Arithmetic.euclideanAlgorithm numerator denominator).Hcf
+
+        {
+            Numerator = numerator / hcf
+            Denominator = denominator / hcf
+        }
+
+    static member inline (*) (a : Rational<'a>, b : Rational<'a>) =
+        let numerator = a.Numerator * b.Numerator
+        let denominator = a.Denominator * b.Denominator
+        let hcf = (Arithmetic.euclideanAlgorithm numerator denominator).Hcf
+
+        {
+            Numerator = numerator / hcf
+            Denominator = denominator / hcf
+        }
+
+[<RequireQualifiedAccess>]
+module Rational =
+    let inline ofInt< ^a
+        when 'a : (static member (+) : 'a * 'a -> 'a)
+        and 'a : (static member (*) : 'a * 'a -> 'a)
+        and 'a : (static member (/) : 'a * 'a -> 'a)
+        and 'a : (static member (-) : 'a * 'a -> 'a)
+        and 'a : (static member Zero : 'a)
+        and 'a : (static member One : 'a)
+        and 'a : comparison>
+        (a : 'a)
+        =
+        {
+            Numerator = a
+            Denominator = LanguagePrimitives.GenericOne
+        }
+
+    let inline make< ^a
+        when 'a : (static member (+) : 'a * 'a -> 'a)
+        and 'a : (static member (*) : 'a * 'a -> 'a)
+        and 'a : (static member (/) : 'a * 'a -> 'a)
+        and 'a : (static member (-) : 'a * 'a -> 'a)
+        and 'a : (static member Zero : 'a)
+        and 'a : (static member One : 'a)
+        and 'a : comparison>
+        (numerator : 'a)
+        (denominator : 'a)
+        =
+        let hcf = (Arithmetic.euclideanAlgorithm numerator denominator).Hcf
+
+        {
+            Numerator = numerator / hcf
+            Denominator = denominator / hcf
+        }
+
+    let inline assertIntegral< ^a
+        when 'a : (static member (+) : 'a * 'a -> 'a)
+        and 'a : (static member (*) : 'a * 'a -> 'a)
+        and 'a : (static member (/) : 'a * 'a -> 'a)
+        and 'a : (static member (-) : 'a * 'a -> 'a)
+        and 'a : (static member Zero : 'a)
+        and 'a : (static member One : 'a)
+        and 'a : comparison>
+        (r : Rational<'a>)
+        =
+        r.Numerator