port some aoc solutions to zern

examples/puzzles/aoc2024_01.zr

@@ -0,0 +1,35 @@
+func part1[l1: Array, l2: Array] : Void
+    let out: I64 = 0
+    
+    for i in 0..array.size(l1)
+        out = out + math.abs(array.nth(l1, i) - array.nth(l2, i))
+
+    io.println_i64(out)
+
+func part2[l1: Array, l2: Array] : Void
+    let out: I64 = 0
+
+    for i in 0..array.size(l1)
+        out = out + array.nth(l1, i) * alg.count(l2, array.nth(l1, i))
+
+    io.println_i64(out)
+
+func main[] : I64
+    let lines: Array = io.read_file("input.txt") |> str.split("\n")
+
+    let l1: Array = []
+    let l2: Array = []
+
+    for i in 0..array.size(lines)
+        let line: String = array.nth(lines, i)
+        
+        let parts: Array = str.split(line, "   ")
+
+        array.push(l1, str.parse_i64(array.nth(parts, 0)))
+        array.push(l2, str.parse_i64(array.nth(parts, 1)))
+
+    alg.quicksort(l1)
+    alg.quicksort(l2)
+
+    part1(l1, l2)
+    part2(l1, l2)

examples/puzzles/aoc2024_02.zr

@@ -0,0 +1,54 @@
+func check[report: Array] : Bool
+    let increasing: Bool = array.nth(report, 0) < array.nth(report, 1)
+
+    for i in 0..array.size(report)-1
+        if array.nth(report, i) > array.nth(report, i + 1) & increasing
+            return false
+        if array.nth(report, i) < array.nth(report, i + 1) & !increasing
+            return false
+
+        let diff: I64 = math.abs(array.nth(report, i) - array.nth(report, i + 1))
+        if diff < 1 | diff > 3
+            return false
+
+    return true
+
+func part1[data: Array] : Void
+    let out: I64 = 0
+
+    for i in 0..array.size(data)
+        if check(array.nth(data, i))
+            out = out + 1
+
+    io.println_i64(out)
+
+func part2[data: Array] : Void
+    let out: I64 = 0
+
+    for i in 0..array.size(data)
+        if check(array.nth(data, i))
+            out = out + 1
+        else
+            for j in 0..array.size(array.nth(data, i))
+                let sliced: Array = array.concat(array.slice(array.nth(data, i), 0, j), array.slice(array.nth(data, i), j + 1, array.size(array.nth(data, i)) - (j + 1)))
+                
+                if check(sliced)
+                    out = out + 1
+                    break
+
+    io.println_i64(out)
+
+func main[] : I64
+    let lines: Array = io.read_file("input.txt") |> str.split("\n")
+
+    let data: Array = []
+    for i in 0..array.size(lines)
+        let line: String = array.nth(lines, i)
+
+        let report: Array = str.split(line, " ")
+        for i in 0..array.size(report)
+            array.set(report, i, str.parse_i64(array.nth(report, i)))
+        array.push(data, report)
+
+    part1(data)
+    part2(data)

examples/puzzles/aoc2024_04.zr

@@ -0,0 +1,62 @@
+func check[lines: Array, x: I64, y: I64, dx: I64, dy: I64] : Bool
+    if x + dx * 3 < 0 | x + dx * 3 >= array.size(lines) | y + dy * 3 < 0 | y + dy * 3 >= str.len(array.nth(lines, 0))
+        return false
+    
+    if array.nth(lines, x)[y] != 'X'
+        return false
+    if array.nth(lines, x + dx)[y + dy] != 'M'
+        return false
+    if array.nth(lines, x + dx * 2)[y + dy * 2] != 'A'
+        return false
+    if array.nth(lines, x + dx * 3)[y + dy * 3] != 'S'
+        return false
+    
+    return true
+
+func part1[lines: Array] : Void
+    let out: I64 = 0
+
+    for x in 0..array.size(lines)
+        for y in 0..str.len(array.nth(lines, x))
+            if check(lines, x, y, 0, 1)
+                out = out + 1
+            if check(lines, x, y, 0, -1)
+                out = out + 1
+            if check(lines, x, y, 1, 0)
+                out = out + 1
+            if check(lines, x, y, -1, 0)
+                out = out + 1
+            if check(lines, x, y, 1, 1)
+                out = out + 1
+            if check(lines, x, y, -1, -1)
+                out = out + 1
+            if check(lines, x, y, 1, -1)
+                out = out + 1
+            if check(lines, x, y, -1, 1)
+                out = out + 1
+
+    io.println_i64(out)
+
+func part2[lines: Array] : Void
+    let out: I64 = 0
+
+    for x in 1..array.size(lines)-1
+        for y in 1..str.len(array.nth(lines, x))-1
+            if array.nth(lines, x)[y] == 'A'
+                let s: String = mem.alloc(5)
+                str.set(s, 0, array.nth(lines, x - 1)[y - 1])
+                str.set(s, 1, array.nth(lines, x + 1)[y - 1])
+                str.set(s, 2, array.nth(lines, x + 1)[y + 1])
+                str.set(s, 3, array.nth(lines, x - 1)[y + 1])
+                str.set(s, 4, 0)
+
+                if str.equal(s, "MSSM") | str.equal(s, "SMMS") | str.equal(s, "MMSS") | str.equal(s, "SSMM")
+                    out = out + 1
+
+    io.println_i64(out)
+
+func main[] : I64
+    let lines: Array = io.read_file("input.txt") |> str.split("\n")
+
+    part1(lines)
+    part2(lines)

examples/puzzles/aoc2024_05.zr

@@ -0,0 +1,73 @@
+func rule_exists[rules_left: Array, rules_right: Array, a: I64, b: I64] : Bool
+    for k in 0..array.size(rules_left)
+        if array.nth(rules_left, k) == a & array.nth(rules_right, k) == b
+            return true
+    return false
+
+func check[update: Array, rules_left: Array, rules_right: Array] : Bool
+    for i in 0..array.size(update)
+        for j in 0..i
+            if rule_exists(rules_left, rules_right, array.nth(update, i), array.nth(update, j))
+                return false
+    return true
+
+func sort_by_rules[update: Array, rules_left: Array, rules_right: Array] : Void
+    let swapped: Bool = true
+
+    while swapped
+        swapped = false
+        for i in 0..array.size(update)-1
+            let a: I64 = array.nth(update, i)
+            let b: I64 = array.nth(update, i+1)
+            if rule_exists(rules_left, rules_right, b, a)
+                let tmp: I64 = a
+                array.set(update, i, b)
+                array.set(update, i+1, tmp)
+                swapped = true
+
+func part1[updates: Array, rules_left: Array, rules_right: Array] : Void
+    let out: I64 = 0
+
+    for i in 0..array.size(updates)
+        let update: Array = array.nth(updates, i)
+        if check(update, rules_left, rules_right)
+            out = out + array.nth(update, array.size(update) / 2)
+
+    io.println_i64(out)
+
+func part2[updates: Array, rules_left: Array, rules_right: Array] : Void
+    let out: I64 = 0
+
+    for i in 0..array.size(updates)
+        let update: Array = array.nth(updates, i)
+        if !check(update, rules_left, rules_right)
+            sort_by_rules(update, rules_left, rules_right)
+            out = out + array.nth(update, array.size(update) / 2)
+
+    io.println_i64(out)
+
+func main[] : I64
+    let data: Array = io.read_file("input.txt") |> str.split("\n\n")
+
+    let rules_left: Array = []
+    let rules_right: Array = []
+    let rules_lines: Array = str.split(array.nth(data, 0), "\n")
+    for i in 0..array.size(rules_lines)
+        let line: String = array.nth(rules_lines, i)
+        let parts: Array = str.split(line, "|")
+
+        array.push(rules_left, str.parse_i64(array.nth(parts, 0)))
+        array.push(rules_right, str.parse_i64(array.nth(parts, 1)))
+
+    let updates: Array = []
+    let updates_lines: Array = str.split(array.nth(data, 1), "\n")
+    for i in 0..array.size(updates_lines)
+        let line: String = array.nth(updates_lines, i)
+        let xs: Array = str.split(line, ",")
+
+        for i in 0..array.size(xs)
+            array.set(xs, i, str.parse_i64(array.nth(xs, i)))
+        array.push(updates, xs)
+
+    part1(updates, rules_left, rules_right)
+    part2(updates, rules_left, rules_right)

examples/puzzles/aoc2025_03.zr

@@ -0,0 +1,51 @@
+func part1[lines: Array] : Void
+    let sum: I64 = 0
+
+    for i in 0..array.size(lines)
+        let line: String = array.nth(lines, i)
+
+        let largest: I64 = 0
+        for j in 0..str.len(line)
+            for k in (j+1)..str.len(line)
+                let s: String = mem.alloc(3)
+                str.set(s, 0, line[j])
+                str.set(s, 1, line[k])
+                str.set(s, 2, 0)
+                let n: I64 = str.parse_i64(s)
+                if n > largest
+                    largest = n
+
+        sum = sum + largest
+    io.println_i64(sum)
+
+// had to cheat this one
+func part2_rec[bank: String, start: I64, remaining: I64] : I64
+    let largest: I64 = 0
+    let largest_idx: I64 = start
+    let len: I64 = str.len(bank)
+
+    for i in (start)..(len-remaining+1)
+        let v: I64 = bank[i] - '0'
+        if v > largest
+            largest = v
+            largest_idx = i
+
+    if remaining > 1
+        return largest * math.pow(10, remaining - 1) + part2_rec(bank, largest_idx + 1, remaining - 1)
+    else
+        return largest
+
+func part2[lines: Array] : Void
+    let sum: I64 = 0
+
+    for i in 0..array.size(lines)
+        let line: String = array.nth(lines, i)
+
+        sum = sum + part2_rec(line, 0, 12)
+    io.println_i64(sum)
+
+func main[] : I64
+    let lines: Array = io.read_file("input.txt") |> str.split("\n")
+
+    part1(lines)
+    part2(lines)