day4

Author: spaenleh

Sources/AdventOfCode.swift

@@ -5,6 +5,7 @@ let allChallenges: [any AdventDay] = [
   Day01(),
   Day02(),
   Day03(),
+  Day04(),
 ]
 
 @main

Sources/Day04.swift

@@ -0,0 +1,71 @@
+import Algorithms
+
+func searchInNeighbors(pos: Coord, _ grid: Grid) -> [Coord] {
+  pos.fullNeighbors.included(in: grid).filter { n in
+    grid[n] == "M"
+  }
+}
+
+func isMAS(pos: Coord, _ grid: Grid) -> Bool {
+  let candidates = pos.cornerNeighbors
+  if (candidates.allSatisfy { $0.isInside(grid: grid) }) {
+    let l = candidates.map { grid[$0] }
+    let letterSet = Set(l)
+    // same letter can not be on opposite side
+    return l[0] != l[2] && l[1] != l[3] && letterSet.count == 2 && letterSet == ["M", "S"]
+  }
+  return false
+}
+
+func isWhole(pos: Coord, inDir: Coord, grid: Grid) -> Bool {
+  let aPos = pos + inDir
+  let sPos = aPos + inDir
+  if aPos.isInside(grid: grid) && sPos.isInside(grid: grid) {
+    return grid[aPos] == "A" && grid[sPos] == "S"
+  }
+  return false
+}
+
+struct Day04: AdventDay {
+  var data: String
+  var grid: Grid {
+    Grid(from: data)
+  }
+
+  func countAllWhere(letter search: Character, predicate: (Coord, Grid) -> Bool) -> Int {
+    grid.raw.enumerated().map { (y, line) in
+      line.enumerated().map { (x, letter) in
+        if letter == search {
+          return predicate(Coord(x: x, y: y), grid)
+        }
+        return false
+      }
+    }.flatMap { $0 }.count { $0 == true }
+  }
+
+  func part1() -> Int {
+    var count = 0
+    // get all positions of "X"
+    for (y, line) in grid.raw.enumerated() {
+      for (x, letter) in line.enumerated() {
+        if letter == "X" {
+          let currentPos = Coord(x: x, y: y)
+          let results = searchInNeighbors(pos: currentPos, grid)
+          if results.count > 0 {
+            for candidate in results {
+              let inDir = candidate - currentPos
+              if isWhole(pos: candidate, inDir: inDir, grid: grid) {
+                count += 1
+              }
+            }
+          }
+        }
+      }
+    }
+    return count
+  }
+
+  func part2() -> Int {
+    countAllWhere(letter: "A", predicate: isMAS)
+  }
+}

Sources/Extensions/String+Parsing.swift

@@ -14,6 +14,10 @@ extension StringProtocol {
     self.split(separator: "\n")
   }
 
+  func toCharacterGrid() -> [[Substring.Element]] {
+    self.lines().map { Array($0) }
+  }
+
   func integers(separator: String = " ") -> [Int] {
     self.split(separator: separator).map { Int($0) }.compactMap { $0 }
   }

Sources/Helpers/Coord.swift

@@ -0,0 +1,61 @@
+struct Coord {
+  var x: Int
+  var y: Int
+
+  /// Offsets for the corner elements (X shape)
+  /// Corners are ordered clockwise starting at the top left
+  /// top left, top right, bottom right, bottom left
+  static let corners = [
+    Coord(x: -1, y: -1),
+    Coord(x: 1, y: -1),
+    Coord(x: 1, y: 1),
+    Coord(x: -1, y: 1),
+  ]
+
+  /// Offsets for the cross elements (+ shape)
+  ///
+  static let cross = [
+    Coord(x: 0, y: -1),
+    Coord(x: 0, y: 1),
+    Coord(x: -1, y: 0),
+    Coord(x: 1, y: 0),
+  ]
+
+  var cornerNeighbors: [Coord] {
+    Coord.corners.map { self + $0 }
+  }
+
+  var crossNeighbors: [Coord] {
+    Coord.cross.map { self + $0 }
+  }
+
+  var fullNeighbors: [Coord] {
+    self.cornerNeighbors + self.crossNeighbors
+  }
+
+  func isInside(grid: Grid) -> Bool {
+    self.x >= 0 && self.x <= grid.width - 1 && self.y >= 0 && self.y <= grid.height - 1
+  }
+
+}
+
+extension Coord: Equatable {}
+
+extension Coord: AdditiveArithmetic {
+  static let zero = Coord(x: 0, y: 0)
+
+  // add conformance for the AdditiveArithmetic protocol
+  static func + (lhs: Self, rhs: Self) -> Self {
+    return Self(x: lhs.x + rhs.x, y: lhs.y + rhs.y)
+  }
+
+  static func - (lhs: Self, rhs: Self) -> Self {
+    return Self(x: lhs.x - rhs.x, y: lhs.y - rhs.y)
+  }
+}
+
+extension Array where Array.Element == Coord {
+  func included(in grid: Grid) -> Self {
+    self.filter { $0.isInside(grid: grid) }
+  }
+}

Sources/Helpers/Grid.swift

@@ -0,0 +1,32 @@
+struct Grid {
+  typealias Element = Character
+
+  var raw: [[Element]]
+
+  // dimensions
+  var width: Int {
+    raw[0].count
+  }
+  var height: Int {
+    raw.count
+  }
+
+  subscript(_ coord: Coord) -> Element {
+    raw[coord.y][coord.x]
+  }
+
+  subscript(col: Int, row: Int) -> Element {
+    raw[row][col]
+  }
+}
+
+extension Grid {
+  /// creates a Grid of characters from a multiline string
+  init(from data: String) {
+    self.raw = data.lines().map { Array($0) }
+  }
+
+  func includes(coord: Coord) -> Bool {
+    coord.x >= 0 && coord.x <= self.width - 1 && coord.y >= 0 && coord.y <= self.height - 1
+  }
+}

Tests/Day04.swift

@@ -0,0 +1,56 @@
+import Testing
+
+@testable import aoc
+
+@Suite("Day04")
+struct Day04Tests {
+  let testData = """
+    MMMSXXMASM
+    MSAMXMSMSA
+    AMXSXMAAMM
+    MSAMASMSMX
+    XMASAMXAMM
+    XXAMMXXAMA
+    SMSMSASXSS
+    SAXAMASAAA
+    MAMMMXMMMM
+    MXMXAXMASX
+    """
+
+  @Test("Neighbor search")
+  func testNeighborSearch() async throws {
+    let grid = Grid(
+      from: """
+        XMAS
+        XMAS
+        XMAS
+        XMAS
+        """)
+    #expect(
+      searchInNeighbors(pos: Coord(x: 0, y: 0), grid) == [Coord(x: 1, y: 0), Coord(x: 1, y: 1)])
+  }
+
+  @Test("part1 simple")
+  func testSimplePart1() async throws {
+    let grid = """
+      XMAS
+      XMAS
+      XMAS
+      XMAS
+      """
+    let challenge = Day04(data: grid)
+    #expect(challenge.part1() == 2)
+  }
+
+  @Test("part1")
+  func testPart1() async throws {
+    let challenge = Day04(data: testData)
+    #expect(challenge.part1() == 18)
+  }
+
+  @Test("part2")
+  func testPart2() async throws {
+    let challenge = Day04(data: testData)
+    #expect(challenge.part2() == 9)
+  }
+}

Tests/Helpers/Grid.swift

@@ -0,0 +1,16 @@
+import Testing
+
+@testable import aoc
+
+@Suite("Grid")
+struct GridTests {
+  @Test func testGridCreation() async throws {
+    let unitGrid = Grid(raw: [["0"]])
+    #expect(unitGrid.width == 1)
+    #expect(unitGrid.height == 1)
+    let highGrid = Grid(raw: [["1"], ["2"]])
+
+    #expect(highGrid.width == 1)
+    #expect(highGrid.height == 2)
+  }
+}