reboot6675

I remember when some students did a PoC of this to showcase the dangers of the glasses, and Meta replied like "why are we to blame, it would have worked the same with any camera". Well, any other camera doesn't look like a regular pair of glasses motherfucker.

https://www.404media.co/whats-the-difference-between-ai-glasses-and-an-iphone-a-helpful-guide-for-meta-pr/

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.

Oh man good memories from Simpsons Hit & Run, this is awesome!

Just pointing out that these 2 are not necessarily contradicting statements. Just because it hasn't taken any jobs yet, doesn't mean it won't take any in the next 10 years. Not that I really want to believe those numbers though. But yeah as others have pointed out, these studies need to be taken with a grain of salt.

Just yesterday I came across some Sora generated memes and damn, it was obviously fake (to me) but it looked so real, I am sure some people out there will totally believe this stuff. Misinformation is going to get wild