add hillerstorm day 1 through 4 (#30)

Author: hillerstorm

2023/01/hillerstorm.v

@@ -0,0 +1,59 @@
+module main
+
+import arrays
+import os
+
+const numbers = [
+	'0',
+	'1',
+	'2',
+	'3',
+	'4',
+	'5',
+	'6',
+	'7',
+	'8',
+	'9',
+	'zero',
+	'one',
+	'two',
+	'three',
+	'four',
+	'five',
+	'six',
+	'seven',
+	'eight',
+	'nine',
+]
+
+struct Match {
+	value string
+	idx   int
+}
+
+fn main() {
+	part_one := arrays.sum(os.read_lines('trebuchet-part1.input')!
+		.map(it.split('').filter(it in numbers[..10]))
+		.filter(it.len > 0)
+		.map((it.first() + it.last()).int()))!
+
+	part_two := arrays.sum(os.read_lines('trebuchet-part2.input')!
+		.map(fn (line string) int {
+			mut first_indices := numbers
+				.filter(line.index(it) or { -1 } > -1)
+				.map(Match{it, line.index(it) or { -1 }})
+			first_indices.sort(a.idx < b.idx)
+			first_num := numbers[numbers.index(first_indices.first().value) % 10]
+
+			mut last_indices := numbers
+				.filter(line.index(it) or { -1 } > -1)
+				.map(Match{it, line.last_index(it) or { -1 }})
+			last_indices.sort(a.idx < b.idx)
+			last_num := numbers[numbers.index(last_indices.last().value) % 10]
+
+			return (first_num + last_num).int()
+		}))!
+
+	println('Part 1: ${part_one}')
+	println('Part 2: ${part_two}')
+}

2023/02/hillerstorm.v

@@ -0,0 +1,53 @@
+module main
+
+import math
+import os
+
+const bag = {
+	'red':   12
+	'green': 13
+	'blue':  14
+}
+
+fn main() {
+	mut part_one := 0
+	mut part_two := 0
+
+	for line in os.read_lines('cube.input')! {
+		parts := line.split(': ')
+
+		mut valid := true
+		mut min_red := 0
+		mut min_green := 0
+		mut min_blue := 0
+
+		for set in parts[1].split('; ') {
+			for cube in set.split(', ') {
+				cube_parts := cube.split(' ')
+				color := cube_parts[1]
+				count := cube_parts[0].int()
+
+				if color == 'red' {
+					min_red = math.max(min_red, count)
+				} else if color == 'green' {
+					min_green = math.max(min_green, count)
+				} else if color == 'blue' {
+					min_blue = math.max(min_blue, count)
+				}
+
+				if bag[color] < count {
+					valid = false
+				}
+			}
+		}
+
+		if valid {
+			part_one += parts[0].split(' ')[1].int()
+		}
+
+		part_two += min_red * min_green * min_blue
+	}
+
+	println('Part 1: ${part_one}')
+	println('Part 2: ${part_two}')
+}

2023/03/hillerstorm.v

@@ -0,0 +1,81 @@
+module main
+
+import arrays
+import os
+
+const digits = '0123456789'.runes()
+
+fn main() {
+	lines := os.read_lines('schematic.input')!
+
+	width := lines[0].len + 2
+	deltas := [
+		-width - 1,
+		-width,
+		-width + 1,
+		-1,
+		1,
+		width - 1,
+		width,
+		width + 1,
+	]
+
+	extra_row := '.'.repeat(width)
+	mut padded := [extra_row]
+	padded << lines.map('.${it}.')
+	padded << extra_row
+
+	grid := arrays.flatten(padded.map(it.runes()))
+
+	mut part_one := 0
+
+	mut digit := ''
+	mut digit_indices := []int{}
+	mut gears := map[int][]int{}
+	for idx, chr in grid {
+		if chr in digits {
+			digit += chr.str()
+			digit_indices << idx
+			continue
+		}
+
+		if digit.len > 0 {
+			digit_value := digit.int()
+			if is_part(digit_indices, digit_value, grid, deltas, mut gears) {
+				part_one += digit_value
+			}
+		}
+
+		digit = ''
+		digit_indices = []
+	}
+
+	part_two := arrays.sum(gears
+		.keys()
+		.filter(gears[it].len == 2)
+		.map(arrays.reduce(gears[it], fn (a int, b int) int {
+			return a * b
+		})!))!
+
+	println('Part 1: ${part_one}')
+	println('Part 2: ${part_two}')
+}
+
+fn is_part(digit_indices []int, digit_value int, grid []rune, deltas []int, mut gears map[int][]int) bool {
+	neighbours := digit_indices.map(fn [deltas] (i int) []int {
+		return deltas.map(i + it)
+	})
+
+	mut result := false
+	for idx in arrays.map_of_indexes[int](arrays.flatten(neighbours)).keys() {
+		chr := grid[idx]
+		if chr == `.` || chr in digits {
+			continue
+		} else if chr == `*` {
+			gears[idx] << digit_value
+		}
+		result = true
+	}
+
+	return result
+}

2023/04/hillerstorm.v

@@ -0,0 +1,35 @@
+module main
+
+import arrays
+import math
+import os
+
+fn main() {
+	mut part_one := i64(0)
+
+	mut cards := map[int]int{}
+	mut max_real_id := 0
+
+	for line in os.read_lines('scratchcards.input')! {
+		parts := line.split(': ')
+		numbers := parts[1].split(' | ')
+		winning_numbers := numbers[0].split(' ').filter(it.len > 0).map(it.int())
+		own_numbers := numbers[1].split(' ').filter(it.len > 0).map(it.int())
+		matching_numbers := own_numbers.filter(it in winning_numbers).len
+
+		card := parts[0].split(' ').last().int()
+		cards[card] += 1
+		max_real_id = math.max(max_real_id, card)
+
+		for id in []int{len: matching_numbers, init: card + index + 1} {
+			cards[id] += cards[card]
+		}
+
+		part_one += math.powi(2, matching_numbers) / 2
+	}
+
+	part_two := arrays.sum(cards.keys().filter(it <= max_real_id).map(cards[it]))!
+
+	println('Part 1: ${part_one}')
+	println('Part 2: ${part_two}')
+}

2023/04/scratchcards.input

@@ -0,0 +1,6 @@
+Card 1: 41 48 83 86 17 | 83 86  6 31 17  9 48 53
+Card 2: 13 32 20 16 61 | 61 30 68 82 17 32 24 19
+Card 3:  1 21 53 59 44 | 69 82 63 72 16 21 14  1
+Card 4: 41 92 73 84 69 | 59 84 76 51 58  5 54 83
+Card 5: 87 83 26 28 32 | 88 30 70 12 93 22 82 36
+Card 6: 31 18 13 56 72 | 74 77 10 23 35 67 36 11

known_outputs/2023/01/hillerstorm.out

@@ -0,0 +1,2 @@
+Part 1: 142
+Part 2: 281

known_outputs/2023/02/hillerstorm.out

@@ -0,0 +1,2 @@
+Part 1: 8
+Part 2: 2286

known_outputs/2023/03/hillerstorm.out

@@ -0,0 +1,2 @@
+Part 1: 4361
+Part 2: 467835

known_outputs/2023/04/hillerstorm.out

@@ -0,0 +1,2 @@
+Part 1: 13
+Part 2: 30