Terrible

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

@@ -3,14 +3,140 @@ namespace AdventOfCode2023
 open System
 open System.Collections.Generic
 
+[<Struct>]
+type Range =
+    {
+        SourceStart : uint64
+        DestStart : uint64
+        Len : uint64
+    }
+
 [<RequireQualifiedAccess>]
 module Day5 =
 
+    let remap (range : Range) (i : uint64) =
+        if range.SourceStart <= i && i < range.SourceStart + range.Len then
+            i - range.SourceStart + range.DestStart
+            |> ValueSome
+        else
+            ValueNone
+
+    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 (UInt64.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.consumeU64 &line
+                    let sourceStart = StringSplitEnumerator.consumeU64 &line
+                    let rangeLen = StringSplitEnumerator.consumeU64 &line
+                    {
+                        SourceStart = sourceStart
+                        DestStart = destStart
+                        Len = rangeLen
+                    }
+                    |> currentMapping.Add
+
+        seeds, mappings
+
     let part1 (s : string) =
-        use lines = StringSplitEnumerator.make '\n' s
-        0
+        let seeds, mappings = parse s
 
-    let part2 (s : string) =
-        use lines = StringSplitEnumerator.make '\n' s
+        let mutable best = UInt64.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
+                        match remap interval remapped with
+                        | ValueNone ->
+                            ()
+                        | ValueSome n ->
+                            hasRemappedThisLayer <- true
+                            remapped <- n
+            if remapped < best then
+                best <- remapped
 
-        0
+        best
+
+    let private split (ranges : (uint64 * uint64) ResizeArray) (newRange : Range) : unit =
+        let startsStack = ResizeArray ()
+        let endsStack = ResizeArray ()
+        startsStack.Add newRange.SourceStart
+        endsStack.Add (newRange.SourceStart + newRange.Len - 1uL)
+        while startsStack.Count > 0 do
+            let mutable i = 0
+            while i < ranges.Count do
+                let low, high = ranges.[i]
+                if low <= startsStack.[startsStack.Count - 1] && endsStack.[endsStack.Count - 1] <= high then
+                    // splitting because:
+                    // low ... start .. finish .. high
+                    ranges.[i] <- (low, startsStack.[startsStack.Count - 1])
+                    ranges.Add (startsStack.[startsStack.Count - 1], endsStack.[endsStack.Count - 1])
+                    ranges.Add (endsStack.[endsStack.Count - 1], high)
+                    startsStack.RemoveAt (startsStack.Count - 1)
+                    endsStack.RemoveAt (endsStack.Count - 1)
+                elif low <= startsStack.[startsStack.Count - 1] && high < endsStack.[endsStack.Count - 1] then
+                    // splitting because:
+                    // low .. start .. high .. finish
+                    ranges.[i] <- (low, startsStack.[startsStack.Count - 1])
+                    ranges.Add (startsStack.[startsStack.Count - 1], high)
+                    startsStack.[startsStack.Count - 1] <- high
+                elif low > startsStack.[startsStack.Count - 1] && low < newRange.SourceStart + newRange.Len && newRange.SourceStart + newRange.Len < high then
+                    // splitting because:
+                    // start .. low .. finish .. high
+                    ranges.[i] <- (low, endsStack.[endsStack.Count - 1])
+                    ranges.Add (endsStack.[endsStack.Count - 1], high)
+                    endsStack.[endsStack.Count - 1] <- low
+                elif low > newRange.SourceStart && low < newRange.SourceStart + newRange.Len && high < newRange.SourceStart + newRange.Len then
+                    // splitting because:
+                    // start .. low .. high .. finish
+                    failwith ""
+                i <- i + 1
+
+    let part2 (s : string) : uint64 =
+        let seeds, mappings = parse s
+
+        let chunks = seeds |> Array.splitInto (seeds.Length / 2)
+        chunks
+        |> Array.Parallel.map (fun arr ->
+            let start, len = match arr with | [| s ; l |] -> s, l | _ -> failwith "bad"
+            let mutable best = UInt64.MaxValue
+            for seed in start .. start + len - uint64 1 do
+                let mutable remapped = seed
+                for map in mappings do
+                    let mutable hasRemappedThisLayer = false
+                    for interval in map do
+                        if not hasRemappedThisLayer then
+                            match remap interval remapped with
+                            | ValueNone ->
+                                ()
+                            | ValueSome n ->
+                                hasRemappedThisLayer <- true
+                                remapped <- n
+                if remapped < best then
+                    best <- remapped
+            best
+        )
+        |> Array.min