reboot6675

• One flew over the cuckoo's nest
• Aftersun
• The father
• Manchester by the sea
• Million dollar baby

Yeah, but back then no work, no responsibilities, friends not busy all the time...

Go

Now I'm behind by 1 day, will try to catch up.

For part 2 I spent a good while thinking about it, then when I convinced myself my plan could work, struggled a bit with the implementation. But it worked in the end. Basically grid[i][j] is how many different ways you can reach a cell. Start at 1 on the S cell, then propagate the values down and keep adding up the nums when you reach cells through different paths. The answer is the sum of the nums in the last row.

func part2() {
	// file, _ := os.Open("sample.txt")
	file, _ := os.Open("input.txt")
	defer file.Close()
	scanner := bufio.NewScanner(file)

	input := [][]rune{}

	for scanner.Scan() {
		line := []rune(scanner.Text())
		input = append(input, line)
	}

	m := len(input)
	n := len(input[0])
	grid := make([][]int, m)
	for i := range m {
		grid[i] = make([]int, n)
	}

	for i := range m {
		for j := range n {
			c := input[i][j]
			if i == 0 {
				if c == 'S' {
					grid[i][j] = 1
				}
				continue
			}
			if c == '^' {
				grid[i][j-1] += grid[i-1][j]
				grid[i][j+1] += grid[i-1][j]
			} else {
				grid[i][j] = grid[i][j] + grid[i-1][j]
			}
		}
	}

	paths := 0
	for j := range n {
		paths += grid[m-1][j]
	}

	fmt.Println(paths)
}

Go

Part 2: Read the whole input in a rune matrix. Scan it column by column, store the numbers as you go, ignoring all spaces, and store the operand when you find it. When you hit an empty column or the end, do the operation and add it to the total.

func part2() {
	// file, _ := os.Open("sample.txt")
	file, _ := os.Open("input.txt")
	defer file.Close()
	scanner := bufio.NewScanner(file)

	chars := [][]rune{}
	for scanner.Scan() {
		chars = append(chars, []rune(scanner.Text()))
	}

	m := len(chars)
	n := len(chars[0])
	var op rune
	nums := []int{}
	total := 0

	for j := range n {
		current := []rune{}
		for i := range m {
			if chars[i][j] == '+' || chars[i][j] == '*' {
				op = chars[i][j]
			} else if chars[i][j] != ' ' {
				current = append(current, chars[i][j])
			}
		}
		if len(current) > 0 {
			x, _ := strconv.Atoi(string(current))
			nums = append(nums, x)
		}
		if len(current) == 0 || j == n-1 {
			result := 0
			if op == '*' {
				result = 1
			}
			for _, x := range nums {
				if op == '+' {
					result = result + x
				} else {
					result = result * x
				}
			}
			total += result
			nums = []int{}
		}
	}

	fmt.Println(total)
}

First I tried to to part 2 with a very poor regex strategy and the performance was abysmal. Switched to plain substrings and boom, instant result.

Golang

func part1() {
	ranges := readInput()
	invalidSum := 0

	for _, r := range ranges {
		parts := strings.Split(r, "-")
		start, _ := strconv.Atoi(parts[0])
		end, _ := strconv.Atoi(parts[1])

		for num := start; num <= end; num++ {
			current := strconv.Itoa(num)
			n := len(current)
			if n%2 != 0 {
				continue
			}
			left := current[:n/2]
			right := current[n/2:]
			if left == right {
				invalidSum += num
			}
		}
	}

	fmt.Println(invalidSum)
}

func part2() {
	ranges := readInput()
	invalidSum := 0

	for _, r := range ranges {
		parts := strings.Split(r, "-")
		start, _ := strconv.Atoi(parts[0])
		end, _ := strconv.Atoi(parts[1])

		for num := start; num <= end; num++ {
			current := strconv.Itoa(num)
			n := len(current)

			for index := 1; index <= n/2; index++ {
				if n%index != 0 {
					continue
				}

				left := 0
				right := index
				prefix := current[left:right]
				isRepeated := true
				for left < n && right < n {
					left = right
					right = right + index
					next := current[left:right]
					if next != prefix {
						isRepeated = false
						break
					}
				}

				if isRepeated {
					invalidSum += num
					break
				}
			}
		}
	}

	fmt.Println(invalidSum)
}

Golang

func part1() {
	// file, _ := os.Open("sample.txt")
	file, _ := os.Open("input.txt")
	defer file.Close()

	scanner := bufio.NewScanner(file)
	n := 100
	current := 50
	pointingAt0 := 0

	for scanner.Scan() {
		line := scanner.Text()
		num, _ := strconv.Atoi(line[1:])
		if line[0] == 'L' {
			current = ((current-num)%n + n) % n
		} else {
			current = (current + num) % n
		}
		if current == 0 {
			pointingAt0++
		}
	}

	fmt.Println(pointingAt0)
}

func part2() {
	// file, _ := os.Open("sample.txt")
	file, _ := os.Open("input.txt")
	defer file.Close()

	scanner := bufio.NewScanner(file)
	n := 100
	current := 50
	pointingAt0 := 0

	for scanner.Scan() {
		line := scanner.Text()
		num, _ := strconv.Atoi(line[1:])

		rounds := num / n
		pointingAt0 += rounds
		num = num % n
		new := -1

		if line[0] == 'L' {
			new = ((current-num)%n + n) % n
			if current != 0 && (new > current || new == 0) {
				pointingAt0++
			}
		} else {
			new = (current + num) % n
			if current != 0 && (new < current || new == 0) {
				pointingAt0++
			}
		}

		current = new
	}

	fmt.Println(pointingAt0)
}

Ohh so it was possible to use floats for this! I was "worried" that it would lead to precision errors haha so I ended up "cheating" with BigInt (Golang) to make all the multiplications first and one division at the end

Borges mentioned. Amazing writer.

I've seen Strawberry mentioned a lot but I'm definitely not a fan of its looks haha. Gapless on the other hand looks pretty sleek. It's a bit less intuitive perhaps but I might give it a shot

Thanks for this tip also, will check it out

Quod Libet looks great, thanks! Probably going to go with this one. Looks pretty similar to Rhythmbox and also does #3 from my list