p1

.gitignore

@@ -1 +1,4 @@
-**/input*.txt
+**/input*.txt
+**/test*.txt
+.DS_Store
+.env

2022/12/l.py

@@ -0,0 +1,70 @@
+import os
+import numpy
+from collections import deque
+
+input = open(os.path.dirname(__file__) +
+             "/input.txt", "r").readlines()
+
+start = ()
+end = ()
+
+terrain = []
+for Y, y in enumerate(input):
+    y = y.strip()
+    cur = []
+    for X, x in enumerate(y):
+        h = ord(x)-ord('a')+1
+        if (x == 'S'):
+            h = 1
+            start = (Y, X)
+        if (x == 'E'):
+            h = 26
+            end = (Y, X)
+        cur.append(h)
+    terrain.append(cur)
+
+H = len(terrain)
+W = len(terrain[0])
+
+neighbours = [(-1, 0), (0, 1), (1, 0), (0, -1)]
+
+
+def find_path(coords):
+    paths = []
+    for n in neighbours:
+        check = tuple(numpy.add(coords, n))
+        if 0 <= check[0] < H and 0 <= check[1] < W and coords != check:
+            if terrain[check[0]][check[1]] <= terrain[coords[0]][coords[1]]+1:
+                paths.append(check)
+    return paths
+
+
+def solve(p):
+    Q = deque()
+
+    if (p == 2):
+        for y in range(H):
+            for x in range(W):
+                if terrain[y][x] == 1:
+                    Q.append(((y, x), 0))
+    else:
+        Q.append((start, 0))
+
+    V = set()
+
+    while Q:
+        cur_pos, d = Q.popleft()
+        if cur_pos in V:
+            continue
+        V.add(cur_pos)
+        if cur_pos == end:
+            return d
+
+        tocheck = find_path(cur_pos)
+
+        for node in tocheck:
+            Q.append((node, d+1))
+
+
+print(solve(1))
+print(solve(2))

2022/13/m.py

@@ -0,0 +1,70 @@
+from functools import cmp_to_key
+import os
+
+input = open(os.path.dirname(__file__) +
+             "/input.txt", "r").read().split('\n\n')
+
+
+def compare(a, b):
+    typea = type(a)
+    typeb = type(b)
+
+    if typea == int and typeb == int:
+        if a < b:
+            return -1
+        elif a == b:
+            return 0
+        else:
+            return 1
+
+    elif typea == list and typeb == list:
+        i = 0
+        while i < len(a) and i < len(b):
+            res = compare(a[i], b[i])
+            if res == 1:
+                return 1
+            if res == -1:
+                return -1
+            i += 1
+
+        if len(a) == i and i < len(b):
+            return -1
+        elif len(b) == i and i < len(a):
+            return 1
+        else:
+            return 0
+
+    elif (typea == int and typeb == list):
+        return compare([a], b)
+
+    elif (typeb == int and typea == list):
+        return compare(a, [b])
+
+
+packets = []
+p1 = 0
+for idx, i in enumerate(input):
+    a, b = i.split('\n')
+    a = eval(a)
+    b = eval(b)
+    packets.append(a)
+    packets.append(b)
+
+    if compare(a, b) == -1:
+        p1 += idx+1
+
+print("p1:", p1)
+
+packets.append([[2]])
+packets.append([[6]])
+
+packets = sorted(packets, key=cmp_to_key(lambda a, b: compare(a, b)))
+
+p2 = 1
+
+for idx, p in enumerate(packets):
+    # print(p)
+    if p == [[2]] or p == [[6]]:
+        p2 *= idx+1
+
+print("p2:", p2)

2022/14/n.py

@@ -0,0 +1,71 @@
+import os
+
+input = open(os.path.dirname(__file__) +
+             "/input.txt", "r").readlines()
+
+cave = set()
+
+for l in input:
+    points = l.strip().split(' -> ')
+    prev = (0, 0)
+    for p in points:
+        x, y = p.split(',')
+        x = int(x)
+        y = int(y)
+        if prev == (0, 0):
+            prev = (y, x)
+            cave.add(prev)
+        else:
+            dy = y-prev[0]
+            dx = x-prev[1]
+            tmp = set()
+            dir = 1
+            if dy < 0 or dx < 0:
+                dir = -1
+            if dy != 0:
+                for i in range(prev[0], prev[0]+dy+dir, dir):
+                    tmp.add((i, prev[1]))
+            if dx != 0:
+                for i in range(prev[1], prev[1]+dx+dir, dir):
+                    tmp.add((prev[0], i))
+            cave.update(tmp)
+            prev = (y, x)
+
+
+floor = max(r[0] for r in cave)+2
+for i in range(-20000, 20000):
+    cave.add((floor, i))
+
+p1 = False
+for s in range(10000000):
+    X = 500
+    Y = 0
+    current = (Y, X)
+    # print(current)
+
+    while (True):
+
+        down = (current[0]+1, current[1])
+        left = (current[0]+1, current[1]-1)
+        right = (current[0]+1, current[1]+1)
+
+        if (current[0]+1 >= floor and not p1):
+            print("p1:", s)
+            p1 = True
+
+        if down not in cave:
+            current = down
+            if current[0] >= floor:
+                break
+        elif left not in cave:
+            current = left
+        elif right not in cave:
+            current = right
+        else:
+            break
+
+    if current == (0, 500):
+        print("p2:", s+1)
+        break
+
+    cave.add(current)

2022/15/o.py

@@ -0,0 +1,48 @@
+import os
+
+input = open(os.path.dirname(__file__) +
+             "/input.txt", "r").readlines()
+
+beacons = []
+sensors = []
+distance = []
+
+for line in input:
+    l = line.strip().split()
+    sx = int(l[2].split('=')[1].split(',')[0])
+    sy = int(l[3].split('=')[1].split(':')[0])
+    bx = int(l[8].split('=')[1].split(',')[0])
+    by = int(l[9].split('=')[1])
+    d = abs(bx-sx)+abs(by-sy)
+    distance.append(d)
+    beacons.append((bx, by))
+    sensors.append((sx, sy))
+    print(sx, sy, bx, by, d)
+
+
+def getcoverage(b, Y):
+    coverage = set()
+    (x, y) = sensors[b]
+    d0 = distance[i]
+    print("check", x, y, d0)
+    for X in range(x-d0, x+d0):
+        if (abs(x-X)+abs(y-Y)) <= d0:
+            coverage.add((X, Y))
+    return coverage
+
+
+testy = 2000000
+
+fullcoverage = set()
+for i in range(len(sensors)):
+    cov = getcoverage(i, testy)
+    fullcoverage.update(cov)
+
+testset = set()
+for s in fullcoverage:
+    if s[1] == testy:
+        testset.add(s)
+
+nonbeacons = testset.difference(set(beacons))
+
+print(len(nonbeacons))

2022/16/p.py

@@ -0,0 +1,14 @@
+import os
+
+input = open(os.path.dirname(__file__) +
+             "/input-demo.txt", "r").readlines()
+
+V = {}
+
+for l in input:
+    d = l.strip().split()
+    V[d[1]] = (int(d[4].split('=')[1].split(';')[0]),
+               d[9:])
+
+
+print(V)

2023/01/go.mod

@@ -0,0 +1,3 @@
+module main
+
+go 1.21.4

2023/01/main.go

@@ -0,0 +1,44 @@
+package main
+
+import (
+	"fmt"
+	"os"
+	"strconv"
+	"strings"
+)
+
+func main() {
+
+	lines := parse()
+
+	var first = 0
+	var last = 0
+
+	for _, line := range lines {
+		fmt.Println(line)
+		for i := 0; i < len(line); i++ {
+			//fmt.Println(int(line[i]))
+			x := strconv.Atoi(line[i])
+			if x {
+				first = x
+				break
+			}
+		}
+		for i := 0; i < len(line); i++ {
+			//fmt.Println(int(line[i]))
+			x, err := strconv.Atoi(line[i])
+			if err == nil {
+				last = x
+				break
+			}
+		}
+	}
+
+}
+
+func parse() []string {
+	filePath := os.Args[1]
+	data, _ := os.ReadFile(filePath)
+	chunks := strings.Split(string(data), "\n")
+	return chunks
+}

2023/go.work

@@ -0,0 +1,5 @@
+go 1.23.3
+
+use (
+	./01
+)

2024/01/go.mod

@@ -0,0 +1,3 @@
+module main
+
+go 1.23.3

2024/01/main.go

@@ -0,0 +1,69 @@
+package main
+
+import (
+	"fmt"
+	"os"
+	"sort"
+	"strconv"
+	"strings"
+)
+
+func main() {
+
+	lines := parse()
+
+	var left = []int{}
+	var right = []int{}
+
+	for _, line := range lines {
+		nums := strings.Fields(line)
+
+		l, _ := strconv.Atoi(nums[0])
+		r, _ := strconv.Atoi(nums[1])
+		left = append(left, l)
+		right = append(right, r)
+
+	}
+
+	sort.Ints(left)
+	sort.Ints(right)
+
+	var sum = 0
+
+	for i := 0; i < len(left); i++ {
+		var diff = right[i] - left[i]
+		if diff < 0 {
+			diff *= -1
+		}
+		sum += diff
+	}
+
+	var similarity = 0
+
+	for i := 0; i < len(left); i++ {
+		var count = 0
+		for j := 0; j < len(right); j++ {
+			if left[i] == right[j] {
+				count += 1
+			}
+		}
+		similarity += count * left[i]
+	}
+	fmt.Println(sum)
+	fmt.Println(similarity)
+
+}
+
+func parse() []string {
+	filePath := os.Args[1]
+	data, _ := os.ReadFile(filePath)
+	chunks := strings.Split(string(data), "\n")
+	var nonEmpthyChunks = []string{}
+
+	for _, chunk := range chunks {
+		if chunk != "" {
+			nonEmpthyChunks = append(nonEmpthyChunks, chunk)
+		}
+	}
+	return nonEmpthyChunks
+}

2024/02/go.mod

@@ -0,0 +1,3 @@
+module main
+
+go 1.23.3

2024/02/main.go

@@ -0,0 +1,115 @@
+package main
+
+import (
+	"fmt"
+	"os"
+	"strconv"
+	"strings"
+)
+
+const (
+	Increasing = 1
+	Decreasing = -1
+)
+
+func absInt(x int) int {
+	return absDiffInt(x, 0)
+}
+
+func absDiffInt(x, y int) int {
+	if x < y {
+		return y - x
+	}
+	return x - y
+}
+
+func checkDirection(x int) int {
+	switch {
+	case x < 0:
+		return Increasing
+	case x > 0:
+		return Decreasing
+	default:
+		return 0
+	}
+}
+
+func checklevel(report []int) bool {
+	dir := checkDirection(report[0] - report[1])
+	for i := 0; i < len(report)-1; i++ {
+		zero := report[i]
+		one := report[i+1]
+		diff := zero - one
+		if newDir := checkDirection(diff); newDir != dir {
+			return false
+		}
+		absDiff := absInt(diff)
+		if absDiff < 1 || absDiff > 3 {
+			return false
+		}
+	}
+	return true
+}
+
+func main() {
+
+	lines, err := parse()
+	if err != nil {
+		fmt.Println("Error:", err)
+	}
+
+	var safes = 0
+	var safes2 = 0
+
+	for _, line := range lines {
+		numbers := strings.Fields(line)
+		report := make([]int, len(numbers))
+		for i, num := range numbers {
+			x, err := strconv.Atoi(num)
+			if err != nil {
+				panic(err)
+			}
+			report[i] = x
+		}
+		if checklevel(report) {
+			safes++
+			safes2++
+		} else {
+			var checks = 0
+			for j := 0; j < len(report); j++ {
+				copyArray := make([]int, len(report))
+				copy(copyArray, report)
+				report2 := append(copyArray[:j], copyArray[j+1:]...)
+				if checklevel(report2) {
+					checks++
+				}
+			}
+			if checks >= 1 {
+				safes2++
+			}
+		}
+	}
+
+	fmt.Println("p1: ", safes)
+	fmt.Println("p2: ", safes2)
+}
+
+func parse() ([]string, error) {
+	if len(os.Args) < 2 {
+		return nil, fmt.Errorf("no file provided")
+	}
+	filePath := os.Args[1]
+	data, err := os.ReadFile(filePath)
+	if err != nil {
+		return nil, fmt.Errorf("error opening file: %v", err)
+	}
+	chunks := strings.Split(string(data), "\n")
+	var nonEmpthyChunks = []string{}
+
+	for _, chunk := range chunks {
+		if chunk != "" {
+			nonEmpthyChunks = append(nonEmpthyChunks, chunk)
+		}
+	}
+	return nonEmpthyChunks, nil
+}

2024/03/go.mod

@@ -0,0 +1,3 @@
+module main
+
+go 1.23.3

2024/03/main.go

@@ -0,0 +1,75 @@
+package main
+
+import (
+	"fmt"
+	"os"
+	"regexp"
+	"strconv"
+	"strings"
+)
+
+func calculate(x string) int {
+
+	clean1 := strings.Replace(x, "mul(", "", -1)
+	clean2 := strings.Replace(clean1, ")", "", -1)
+	splat := strings.Split(clean2, ",")
+
+	l, err := strconv.Atoi(splat[0])
+	if err != nil {
+	}
+	r, err := strconv.Atoi(splat[1])
+	if err != nil {
+	}
+
+	return l * r
+}
+
+func main() {
+
+	lines, err := parse()
+	if err != nil {
+		fmt.Println("Error:", err)
+	}
+	oneline := strings.Join(lines, "")
+
+	var p1 int = 0
+	var p2 int = 0
+
+	re := regexp.MustCompile(`mul\(\d+,\d+\)`)
+	matches := re.FindAllString(oneline, -1)
+	for i := 0; i < len(matches); i++ {
+		p1 += calculate(matches[i])
+	}
+
+	onecleanre := regexp.MustCompile(`(?s)don\'t\(\).*?do\(\)|$`)
+	oneclean := onecleanre.ReplaceAllString(oneline, "")
+
+	re2 := regexp.MustCompile(`mul\(\d+,\d+\)`)
+	matches2 := re2.FindAllString(oneclean, -1)
+	for i := 0; i < len(matches2); i++ {
+		p2 += calculate(matches2[i])
+	}
+
+	fmt.Println("p1: ", p1)
+	fmt.Println("p2: ", p2)
+}
+
+func parse() ([]string, error) {
+	if len(os.Args) < 2 {
+		return nil, fmt.Errorf("no file provided")
+	}
+	filePath := os.Args[1]
+	data, err := os.ReadFile(filePath)
+	if err != nil {
+		return nil, fmt.Errorf("error opening file: %v", err)
+	}
+	chunks := strings.Split(string(data), "\n")
+	var nonEmpthyChunks = []string{}
+
+	for _, chunk := range chunks {
+		if chunk != "" {
+			nonEmpthyChunks = append(nonEmpthyChunks, chunk)
+		}
+	}
+	return nonEmpthyChunks, nil
+}

2024/04/go.mod

@@ -0,0 +1,3 @@
+module main
+
+go 1.23.3

2024/04/main.go

@@ -0,0 +1,126 @@
+package main
+
+import (
+	"fmt"
+	"os"
+	"strings"
+)
+
+func main() {
+
+	lines, err := parse()
+	if err != nil {
+		fmt.Println("Error:", err)
+	}
+
+	var p1 int = 0
+	var p2 int = 0
+
+	h := len(lines)
+	w := len(lines[0])
+
+	for y := 0; y < h; y++ {
+		for x := 0; x < w; x++ {
+
+			if lines[y][x] == 'X' {
+				// check right
+				if x <= len(lines[y])-4 {
+					r := string([]byte{lines[y][x+1], lines[y][x+2], lines[y][x+3]})
+					if r == "MAS" {
+						p1++
+					}
+				}
+
+				// check left
+				if x >= 3 {
+					l := string([]byte{lines[y][x-1], lines[y][x-2], lines[y][x-3]})
+					if l == "MAS" {
+						p1++
+					}
+				}
+
+				// check if up possible
+				if y >= 3 {
+					u := string([]byte{lines[y-1][x], lines[y-2][x], lines[y-3][x]})
+					if u == "MAS" {
+						p1++
+					}
+					if x >= 3 {
+						ul := string([]byte{lines[y-1][x-1], lines[y-2][x-2], lines[y-3][x-3]})
+						if ul == "MAS" {
+							p1++
+						}
+					}
+					if x < w-3 {
+						ur := string([]byte{lines[y-1][x+1], lines[y-2][x+2], lines[y-3][x+3]})
+						if ur == "MAS" {
+							p1++
+						}
+					}
+
+				}
+
+				// check down
+				if y <= h-4 {
+					d := string([]byte{lines[y+1][x], lines[y+2][x], lines[y+3][x]})
+					if d == "MAS" {
+						p1++
+					}
+					if x >= 3 {
+						dl := string([]byte{lines[y+1][x-1], lines[y+2][x-2], lines[y+3][x-3]})
+						if dl == "MAS" {
+							p1++
+						}
+					}
+					if x < w-3 {
+						dr := string([]byte{lines[y+1][x+1], lines[y+2][x+2], lines[y+3][x+3]})
+						if dr == "MAS" {
+							p1++
+						}
+					}
+				}
+			}
+
+			if lines[y][x] == 'A' {
+				if y >= 1 && y < h-1 && x >= 1 && x < w-1 {
+					check := string([]byte{lines[y-1][x-1], lines[y-1][x+1], lines[y+1][x-1], lines[y+1][x+1]})
+					if check == "MSMS" {
+						p2++
+					}
+					if check == "SMSM" {
+						p2++
+					}
+					if check == "MMSS" {
+						p2++
+					}
+					if check == "SSMM" {
+						p2++
+					}
+				}
+			}
+		}
+	}
+
+	fmt.Println("p1: ", p1)
+	fmt.Println("p2: ", p2)
+}
+
+func parse() ([]string, error) {
+	if len(os.Args) < 2 {
+		return nil, fmt.Errorf("no file provided")
+	}
+	filePath := os.Args[1]
+	data, err := os.ReadFile(filePath)
+	if err != nil {
+		return nil, fmt.Errorf("error opening file: %v", err)
+	}
+	chunks := strings.Split(string(data), "\n")
+	var nonEmpthyChunks = []string{}
+
+	for _, chunk := range chunks {
+		if chunk != "" {
+			nonEmpthyChunks = append(nonEmpthyChunks, chunk)
+		}
+	}
+	return nonEmpthyChunks, nil
+}

2024/05/go.mod

@@ -0,0 +1,3 @@
+module main
+
+go 1.23.3

2024/05/main.go

@@ -0,0 +1,102 @@
+package main
+
+import (
+	"fmt"
+	"os"
+	"strconv"
+	"strings"
+)
+
+func contains(s []int, e int) bool {
+	for _, a := range s {
+		if a == e {
+			return true
+		}
+	}
+	return false
+}
+
+func check(nums []int, maps map[int][]int) bool {
+	correct := true
+	for i := 0; i < len(nums); i++ {
+		var checking = nums[i]
+		for j := 0; j < len(nums); j++ {
+
+			if !contains(maps[checking], nums[j]) {
+				if i < j {
+					correct = false
+				}
+			}
+		}
+	}
+
+	return correct
+}
+
+func main() {
+
+	lines, err := parse()
+	if err != nil {
+		fmt.Println("Error:", err)
+	}
+
+	var p1 int = 0
+	var p2 int = 0
+
+	maps := make(map[int][]int)
+
+	for y := 0; y < len(lines); y++ {
+		if lines[y] != "" && lines[y][2] == '|' {
+			split := strings.Split(lines[y], "|")
+			l, err := strconv.Atoi(split[0])
+			if err != nil {
+				panic(err)
+			}
+			r, err := strconv.Atoi(split[1])
+			if err != nil {
+				panic(err)
+			}
+			maps[l] = append(maps[l], r)
+		}
+
+		if lines[y] != "" && lines[y][2] == ',' {
+			numsstr := strings.Split(lines[y], ",")
+			var nums []int
+
+			for i := 0; i < len(numsstr); i++ {
+				x, err := strconv.Atoi(numsstr[i])
+				if err != nil {
+					panic(err)
+				}
+				nums = append(nums, x)
+			}
+
+			if check(nums, maps) {
+				p1 += nums[len(nums)/2]
+			}
+		}
+	}
+
+	fmt.Println("p1: ", p1)
+	fmt.Println("p2: ", p2)
+}
+
+func parse() ([]string, error) {
+	if len(os.Args) < 2 {
+		return nil, fmt.Errorf("no file provided")
+	}
+	filePath := os.Args[1]
+	data, err := os.ReadFile(filePath)
+	if err != nil {
+		return nil, fmt.Errorf("error opening file: %v", err)
+	}
+	chunks := strings.Split(string(data), "\n")
+	var nonEmpthyChunks = []string{}
+
+	for _, chunk := range chunks {
+		if chunk != "" {
+			nonEmpthyChunks = append(nonEmpthyChunks, chunk)
+		}
+	}
+	return nonEmpthyChunks, nil
+}

README.md

@@ -1,3 +1,3 @@
-# Advent of Code 2022
+# Advent of Code
 
 https://adventofcode.com/

testing/test.go

@@ -0,0 +1,24 @@
+package main
+
+import (
+	"fmt"
+	"os"
+	"strings"
+)
+
+func main() {
+
+	lines := parse()
+
+	for _, line := range lines {
+		fmt.Println(line)
+	}
+
+}
+
+func parse() []string {
+	filePath := os.Args[1]
+	data, _ := os.ReadFile(filePath)
+	chunks := strings.Split(string(data), "\n")
+	return chunks
+}

testing/test.txt

@@ -0,0 +1,4 @@
+1
+2
+3 
+3425  423 

utils/getpuzzle.sh

@@ -0,0 +1,9 @@
+#!/bin/bash
+source "$(dirname "$0")/../.env"
+
+year=$1
+day=$2
+
+echo "Getting input for $year day $day"
+
+curl -s -S --cookie "$COOKIE" --output ./input.txt https://adventofcode.com/$year/day/$day/input