day 19

Author: jindraivanek

day19.fsx

@@ -1,4 +1,5 @@
 #r "nuget: Flips"
+
 open Flips
 open Flips.Types
 open Flips.SliceMap
@@ -28,64 +29,79 @@ type Robot =
     | GeodeRobot
 
 let readBlueprint (s: string) =
-        match s with
-        | Match 
-            "Each ore robot costs (.*) ore. Each clay robot costs (.*) ore. Each obsidian robot costs (.*) ore and (.*) clay. Each geode robot costs (.*) ore and (.*) obsidian." 
-            [ oo; co; bo; bc; go; gb ] -> [
-                OreRobot, [ Ore, int oo ]
-                ClayRobot, [ Ore, int co ]
-                ObsidianRobot, [ Ore, int bo; Clay, int bc ]
-                GeodeRobot, [ Ore, int go; Obsidian, int gb ]
-            ]
+    match s with
+    | Match "Each ore robot costs (.*) ore. Each clay robot costs (.*) ore. Each obsidian robot costs (.*) ore and (.*) clay. Each geode robot costs (.*) ore and (.*) obsidian." [ oo
+                                                                                                                                                                                    co
+                                                                                                                                                                                    bo
+                                                                                                                                                                                    bc
+                                                                                                                                                                                    go
+                                                                                                                                                                                    gb ] ->
+        [ OreRobot, [ Ore, int oo ]
+          ClayRobot, [ Ore, int co ]
+          ObsidianRobot, [ Ore, int bo; Clay, int bc ]
+          GeodeRobot, [ Ore, int go; Obsidian, int gb ] ]
 
 let blueprints = lines |> Array.map readBlueprint
 
 let model blueprint totalSteps =
-    let steps = [1..totalSteps]
+    let steps = [ 1..totalSteps ]
     let robotTypes = [ OreRobot; ClayRobot; ObsidianRobot; GeodeRobot ]
     let resourceTypes = [ Ore; Clay; Obsidian; Geode ]
-    let costs = blueprint |> List.collect (fun (r, res) -> res |> List.map (fun (o, x) -> (r, o), float x)) |> SMap2.ofList
-    let robots = 
+
+    let costs =
+        blueprint
+        |> List.collect (fun (r, res) -> res |> List.map (fun (o, x) -> (r, o), float x))
+        |> SMap2.ofList
+
+    let robots =
         DecisionBuilder "robot" {
             for _ in steps do
-                for t in robotTypes ->
-                    Boolean
-            }
-            |> SMap2.ofSeq
-    let robotsCons = 
+                for t in robotTypes -> Boolean
+        }
+        |> SMap2.ofSeq
+
+    let robotsCons =
         ConstraintBuilder "factoryLimit" {
             for i in steps do
                 yield sum robots[i, All] <== 1.0
-            }
-    let collectMult i = [1..i-1] |> List.map (fun j -> j, float (i-j)) |> SMap.ofList
-    let buys = 
+        }
+
+    let collectMult i =
+        [ 1 .. i - 1 ] |> List.map (fun j -> j, float (i - j)) |> SMap.ofList
+
+    let buys =
         ConstraintBuilder "buy" {
             for i in steps do
-                for (t,r) in Seq.zip robotTypes resourceTypes ->
-                    sum (robots[LessThan (i-1), t] .* (collectMult (i-1))) + (if t=OreRobot && i > 1 then float (i-1) else 0.0) >== sum (robots[LessOrEqual i,All] .* costs[All,r])
-            }   
+                for (t, r) in Seq.zip robotTypes resourceTypes ->
+                    sum (robots[LessThan(i - 1), t] .* (collectMult (i - 1)))
+                    + (if t = OreRobot && i > 1 then float (i - 1) else 0.0)
+                    >== sum (robots[LessOrEqual i, All] .* costs[All, r])
+        }
+
     let objExpr = sum (robots.[All, GeodeRobot] .* collectMult totalSteps)
     let objective = Objective.create "Obj" Maximize objExpr
+
     let model =
         Model.create objective
         |> Model.addConstraints robotsCons
         |> Model.addConstraints buys
+
     match Solver.solve Settings.basic model with
     | Optimal sol ->
         //sol.DecisionResults |> Map.filter (fun _ x -> x > 0.0) |> Map.toSeq |> Seq.map (fun (k, x) -> k.Name, x) |> Seq.sort |> Seq.iter (printfn "%A")
         sol.ObjectiveResult |> int
 
 
-let part1() = 
+let part1 () =
     let results = blueprints |> Array.mapi (fun i b -> i, model b 24)
     printfn "%A" results
-    results |> Seq.map (fun (i, x) -> (i+1) * x) |> Seq.sum
+    results |> Seq.map (fun (i, x) -> (i + 1) * x) |> Seq.sum
 
-printfn $"PART1: {part1()}"
+printfn $"PART1: {part1 ()}"
 
-let part2() =
+let part2 () =
     let results = blueprints[..2] |> Array.map (fun b -> model b 32)
     printfn "%A" results
     results |> Seq.reduce (*)
 
-printfn $"PART2: {part2()}"
+printfn $"PART2: {part2 ()}"