finished day 12

Author: devries

README.md

@@ -1,7 +1,7 @@
 # Advent of Code 2025
 
 [![Tests](https://github.com/devries/advent_of_code_2025/actions/workflows/test.yml/badge.svg)](https://github.com/devries/advent_of_code_2025/actions/workflows/test.yml)
-[![Stars: 20](https://img.shields.io/badge/⭐_Stars-20-yellow)](https://adventofcode.com/2025)
+[![Stars: 23](https://img.shields.io/badge/⭐_Stars-23-yellow)](https://adventofcode.com/2025)
 
 This year will be my second year doing Advent of Code in [Gleam](https://gleam.run).
 Last year I was still learning the language, and in the past year I have used it
@@ -58,21 +58,28 @@ information.
     Using the new structure, and making a few other changes, the second part of
     my [solution](src/day08/solution.gleam) is roughly 3 times faster.
 
-- [Day 9](https://adventmfcode.com/2025/day/9): [⭐   solution](src/day09/solution.gleam)
+- [Day 9](https://adventofcode.com/2025/day/9): [⭐   solution](src/day09/solution.gleam)
 
     I ran into an issue doing part 2. I think it is that I am only checking if
     the corners are inside the figure. It may be that the corners are inside,
     but there is a line going through one of the walls. I ran out of time
     this morning to work on this and will pick it up later.
 
-- [Day 10](https://adventmfcode.com/2025/day/10): [⭐   solution](src/day10/solution.gleam)
+- [Day 10](https://adventofcode.com/2025/day/10): [⭐   solution](src/day10/solution.gleam)
 
     I tried doing part 2 a naive way with some memoization, but it seems like
     I still need to work on it. Code was getting very convoluted anyway, not
     pretty like the first several days.
 
-- [Day 11](https://adventmfcode.com/2025/day/11): [⭐ ⭐ solution](src/day11/solution.gleam)
+- [Day 11](https://adventofcode.com/2025/day/11): [⭐ ⭐ solution](src/day11/solution.gleam)
 
     Back on track with today's problem. This is a straightforward depth-first
     search, but I add memoization so I don't have to keep revisiting paths
     I have counted before.
+
+- [Day 12](https://adventofcode.com/2025/day/12): [⭐   solution](src/day12/solution.gleam)
+
+    As I was filtering my input for cases that would require rotation and
+    flipping I realized that none did. There was either enough room for a
+    3x3 present within the area or not enough room for the total area of
+    presents provided. Therefore I didn't have to do anything complex.

inputs

@@ -1,4 +1,3 @@
-import gleam/deque
 import gleam/dict
 import gleam/int
 import gleam/io

src/day11/solution.gleam

@@ -0,0 +1,107 @@
+import gleam/dict
+import gleam/int
+import gleam/io
+import gleam/list
+import gleam/result
+import gleam/set
+import gleam/string
+import internal/aoc_utils
+import internal/point
+
+pub fn main() {
+  let filename = "inputs/day12.txt"
+
+  let lines_result = aoc_utils.read_lines(from: filename)
+  case lines_result {
+    Ok(lines) -> {
+      // If the file was converting into a list of lines
+      // successfully then run each part of the problem
+      aoc_utils.run_part_and_print("Part 1", fn() { solve_p1(lines) })
+    }
+    Error(_) -> io.println("Error reading file")
+  }
+}
+
+// Part 1
+pub fn solve_p1(lines: List(String)) -> Result(String, String) {
+  let sections = aoc_utils.chunk_around_empty_strings(lines)
+
+  let #(present_input, requirements_input) =
+    list.split(sections, list.length(sections) - 1)
+
+  let presents =
+    present_input
+    |> list.map(parse_present)
+    |> dict.from_list
+
+  let requirements =
+    requirements_input
+    |> list.flatten
+    |> list.map(parse_requirements)
+
+  requirements
+  |> list.fold_until(Ok(0), fn(fit_count, r) {
+    case fit_count {
+      Ok(c) ->
+        case definite_fit(r), definite_notfit(r, presents) {
+          True, _ -> list.Continue(Ok(c + 1))
+          _, True -> list.Continue(Ok(c))
+          _, _ -> list.Stop(Error("Marginal fitting case detected"))
+        }
+      _ -> list.Stop(Error("Marginal fitting case detected"))
+    }
+  })
+  |> result.map(int.to_string)
+}
+
+fn parse_present(lines: List(String)) -> #(Int, set.Set(point.Point)) {
+  let assert [index_line, ..shape_lines] = lines
+
+  let assert Ok(present_index) =
+    string.replace(index_line, ":", "") |> int.parse
+
+  let present =
+    shape_lines
+    |> list.index_fold(set.new(), fn(acc, line, y) {
+      string.to_graphemes(line)
+      |> list.index_fold(acc, fn(acc, character, x) {
+        case character {
+          "#" -> set.insert(acc, #(x, y))
+          _ -> acc
+        }
+      })
+    })
+
+  #(present_index, present)
+}
+
+fn parse_requirements(line: String) -> #(point.Point, List(Int)) {
+  let assert Ok(#(dimensions, present_counts)) = string.split_once(line, ": ")
+  let assert Ok(#(x_string, y_string)) = string.split_once(dimensions, "x")
+  let counts =
+    string.split(present_counts, " ") |> list.map(int.parse) |> result.values
+
+  let assert Ok(x) = int.parse(x_string)
+  let assert Ok(y) = int.parse(y_string)
+  #(#(x, y), counts)
+}
+
+fn definite_fit(requirements: #(point.Point, List(Int))) -> Bool {
+  let area = requirements.0.0 * requirements.0.1
+
+  int.sum(requirements.1) * 9 <= area
+}
+
+fn definite_notfit(
+  requirements: #(point.Point, List(Int)),
+  presents: dict.Dict(Int, set.Set(point.Point)),
+) -> Bool {
+  let area = requirements.0.0 * requirements.0.1
+
+  requirements.1
+  |> list.index_fold(0, fn(present_area, present_count, idx) {
+    let assert Ok(p) = dict.get(presents, idx)
+    present_area + { present_count * set.size(p) }
+  })
+  > area
+}

src/day12/solution.gleam

@@ -0,0 +1,41 @@
+import day12/solution
+import gleam/string
+
+const testinput = "0:
+###
+##.
+##.
+
+1:
+###
+##.
+.##
+
+2:
+.##
+###
+##.
+
+3:
+##.
+###
+##.
+
+4:
+###
+#..
+###
+
+5:
+###
+.#.
+###
+
+4x4: 0 0 0 0 2 0
+12x5: 1 0 1 0 2 2
+12x5: 1 0 1 0 3 2"
+
+pub fn part1_test() {
+  let lines = string.split(testinput, "\n")
+  assert solution.solve_p1(lines) == Error("Marginal fitting case detected")
+}