Day 2

gleam.toml

···
 gleam_otp = ">= 0.12.1 and < 1.0.0"
 birl = ">= 1.7.1 and < 2.0.0"
 gleam_regexp = ">= 1.0.0 and < 2.0.0"
+gleam_community_maths = ">= 2.0.0 and < 3.0.0"
 
 [dev-dependencies]
 gleeunit = ">= 1.0.0 and < 2.0.0"

manifest.toml

···
 packages = [
   { name = "birl", version = "1.7.1", build_tools = ["gleam"], requirements = ["gleam_stdlib", "ranger"], otp_app = "birl", source = "hex", outer_checksum = "5C66647D62BCB11FE327E7A6024907C4A17954EF22865FE0940B54A852446D01" },
   { name = "filepath", version = "1.1.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "filepath", source = "hex", outer_checksum = "67A6D15FB39EEB69DD31F8C145BB5A421790581BD6AA14B33D64D5A55DBD6587" },
+  { name = "gleam_community_maths", version = "2.0.0", build_tools = ["gleam"], requirements = ["gleam_stdlib", "gleam_yielder"], otp_app = "gleam_community_maths", source = "hex", outer_checksum = "C9EFF6BCF3C9D113EF9837655B0128CA8CAC295131E9F3468F93C1D78EC3E013" },
   { name = "gleam_erlang", version = "0.32.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleam_erlang", source = "hex", outer_checksum = "B18643083A0117AC5CFD0C1AEEBE5469071895ECFA426DCC26517A07F6AD9948" },
   { name = "gleam_otp", version = "0.14.1", build_tools = ["gleam"], requirements = ["gleam_erlang", "gleam_stdlib"], otp_app = "gleam_otp", source = "hex", outer_checksum = "5A8CE8DBD01C29403390A7BD5C0A63D26F865C83173CF9708E6E827E53159C65" },
   { name = "gleam_regexp", version = "1.0.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleam_regexp", source = "hex", outer_checksum = "A3655FDD288571E90EE9C4009B719FEF59FA16AFCDF3952A76A125AF23CF1592" },
   { name = "gleam_stdlib", version = "0.45.0", build_tools = ["gleam"], requirements = [], otp_app = "gleam_stdlib", source = "hex", outer_checksum = "206FCE1A76974AECFC55AEBCD0217D59EDE4E408C016E2CFCCC8FF51278F186E" },
+  { name = "gleam_yielder", version = "1.1.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleam_yielder", source = "hex", outer_checksum = "8E4E4ECFA7982859F430C57F549200C7749823C106759F4A19A78AEA6687717A" },
   { name = "gleeunit", version = "1.2.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleeunit", source = "hex", outer_checksum = "F7A7228925D3EE7D0813C922E062BFD6D7E9310F0BEE585D3A42F3307E3CFD13" },
   { name = "nibble", version = "1.1.1", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "nibble", source = "hex", outer_checksum = "67C6BEBC1AB6D771AB893B4A7B3E66C92668C6E7774C335FEFCD545B06435FE5" },
   { name = "ranger", version = "1.3.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "ranger", source = "hex", outer_checksum = "B8F3AFF23A3A5B5D9526B8D18E7C43A7DFD3902B151B97EC65397FE29192B695" },
···
 
 [requirements]
 birl = { version = ">= 1.7.1 and < 2.0.0" }
+gleam_community_maths = { version = ">= 2.0.0 and < 3.0.0" }
 gleam_erlang = { version = ">= 0.27.0 and < 1.0.0" }
 gleam_otp = { version = ">= 0.12.1 and < 1.0.0" }
 gleam_regexp = { version = ">= 1.0.0 and < 2.0.0" }

src/aoc.gleam

···
 import birl
 import birl/duration
 import days/day1
+import days/day2
 import gleam/erlang
 import gleam/int
 import gleam/io
···
   case day {
     0 -> io.println_error("Invalid day")
     1 -> day1.start()
+    2 -> day2.start()
     _ -> io.println("Tried to run day " <> int.to_string(day))
   }
   birl.now()

src/days/day2.gleam

···
+import gleam/float
+import gleam/int
+import gleam/io
+import gleam/list
+import gleam/result
+import gleam/string
+import gleam_community/maths
+import simplifile
+import utils/utils
+
+type Range =
+  #(Int, Int)
+
+pub fn start() -> Nil {
+  let assert Ok(content) = simplifile.read("inputs/day2.txt")
+  let data = parse(content)
+
+  let _ = io.debug(part1(data))
+  let _ = io.debug(part2(data))
+
+  Nil
+}
+
+fn parse(data: String) -> List(Range) {
+  data
+  |> string.split(",")
+  |> list.map(fn(x) {
+    let lst =
+      x
+      |> string.split("-")
+      |> list.map(int.parse)
+      |> list.map(result.unwrap(_, 0))
+
+    #(
+      list.first(lst) |> result.unwrap(0),
+      list.drop(lst, 1) |> list.first |> result.unwrap(0),
+    )
+  })
+}
+
+fn is_made_of_part(x: Int) -> Bool {
+  let length =
+    maths.logarithm_10(int.to_float(x))
+    |> result.unwrap(0.0)
+    |> float.floor
+    |> float.add(1.0)
+    |> float.round
+
+  utils.create_int_range(2, length + 1)
+  |> list.filter(fn(y) {
+    int.to_float(length) /. int.to_float(y)
+    == float.floor(int.to_float(length) /. int.to_float(y))
+  })
+  |> list.map(fn(l) {
+    let half_power =
+      { int.to_float(length) /. int.to_float(l) }
+      |> float.floor
+      |> float.power(10.0, _)
+      |> result.unwrap(0.0)
+      |> float.round()
+
+    #(utils.create_int_range(0, l), half_power)
+  })
+  |> list.map(fn(index) {
+    let #(idx, half_power) = index
+    list.map(idx, fn(y) {
+      {
+        int.to_float(x)
+        /. {
+          int.power(half_power, int.to_float(y))
+          |> result.unwrap(1.0)
+        }
+        |> float.modulo(int.to_float(half_power))
+        |> result.unwrap(0.0)
+        |> float.floor
+        |> float.round
+      }
+    })
+  })
+  |> list.any(fn(x) {
+    list.all(x, fn(y) { y == { list.first(x) |> result.unwrap(0) } })
+  })
+}
+
+fn is_symetric(x: Int) -> Bool {
+  let length =
+    maths.logarithm_10(int.to_float(x))
+    |> result.unwrap(0.0)
+    |> float.floor
+    |> float.add(1.0)
+
+  let half_power =
+    float.divide(length, 2.0)
+    |> result.unwrap(0.0)
+    |> float.floor
+    |> float.power(10.0, _)
+    |> result.unwrap(0.0)
+    |> float.round()
+
+  x / half_power == x % half_power
+}
+
+fn part1(data: List(Range)) {
+  data
+  |> list.map(fn(range: Range) {
+    let #(start, end) = range
+    utils.loop(
+      case is_symetric(start) {
+        True -> #(start, start)
+        False -> #(start, 0)
+      },
+      fn(x: #(Int, Int)) {
+        let #(start, _) = x
+        start <= end
+      },
+      fn(x: #(Int, Int)) {
+        let #(start, count) = x
+        case is_symetric(start + 1) {
+          True -> #(start + 1, count + start + 1)
+          False -> #(start + 1, count)
+        }
+      },
+      fn(x: #(Int, Int)) { x },
+    )
+  })
+  |> list.fold(0, fn(acc, v: #(Int, Int)) { acc + v.1 })
+}
+
+fn part2(data) {
+  data
+  |> list.map(fn(range: Range) {
+    let #(start, end) = range
+    utils.loop(
+      case is_made_of_part(start) {
+        True -> #(start, start)
+        False -> #(start, 0)
+      },
+      fn(x: #(Int, Int)) {
+        let #(start, _) = x
+        start <= end
+      },
+      fn(x: #(Int, Int)) {
+        let #(start, count) = x
+        case is_made_of_part(start + 1) {
+          True -> #(start + 1, count + start + 1)
+          False -> #(start + 1, count)
+        }
+      },
+      fn(x: #(Int, Int)) { x },
+    )
+  })
+  |> list.fold(0, fn(acc, v: #(Int, Int)) { acc + v.1 })
+}