Видео

i never understood why its called dynamic programming

What was the problem with `functools.cache`?

my solution for today was insanely similar to yours, im proud of myself now

My bug was that I thought you couldn't reuse towels. The input was constructed in a way that this rendered a correct answer for part 1, but obviously not for part 2.

That was an unfortunate bug. You would've surely gotten top 100 for p2

Interesting bug there. I was too lazy for part1, so I just used regex matching. "^(" + patterns.join('|') + ")*$" does the trick. Ocf I had to implement the counting for part2 anyways. First I just did it recursively, then quickly realized, that it won't finish, so I threw my caching wrapper on it.

When will the Tower of Hanoi stop haunting meee

omg youre back!!!!!!!!!!

using 9 separate min heaps for each empty block size is definitely a good way to go! Very insightful, thanks Neil!

Dude solved in 40 secs what I couldn't solve in two days wth 💀

You know the problem is cooked when this guy is taking an hour to solve it.

No day 18 video? It was an easy one!

I'm not sure the code will look correct, but this was my solution for the second part: def test(a, b, c, prg, k): idx = k while idx < len(prg): b = a % 8 b = b ^ 1 c = int(a / (2**b)) a = int(a / 8) b = b ^ c b = b ^ 6 if b % 8 == prg[idx]: idx += 1 else: return idx return idx prg = [2, 4, 1, 1, 7, 5, 0, 3, 4, 3, 1, 6, 5, 5, 3, 0] def solve(idx, a): if idx < 0: print("solution", a) return for aa in range(0, 8): aaa = 8 * a + aa res = test(aaa, 0, 0, prg, idx) if res == 16: print(idx, res) solve(idx - 1, aaa) solve(15, 0)

I used brute force... But, the trick for me was reducing the range. basically I noticed that the last elements were the last to change, so I just narrowed the range based on the last elements of the output and comparing them with the last elements of program. That way the brute force took like 5 minutes

Amazing. I actually coded your very last idea. No way I could have reverse engineered the thing without any hints. But the recursive DFS with backtracking is simple to code and it works very fast once you figure it out.

you can sort the update by using a custom comparator where instead of a > b you just check if (a,b) in rules. This is because if a,b are in the rules then a must be > b. update.sort(key=functools.cmp_to_key(lambda a,b: -1 if (a,b) in rules else 1))

What an insanely inane problem. Every year has at least one, usually around day 20-23, but this year we seem to get it early. Let's hope there will only be more sensible ones going forward.

You can actually just do modulus, bit shift, and division on bit vecs in z3. I mostly just re-used my code from part 1, replaced "a" with a z3 BitVec variable, and let that build up the right conditions. Had to replace // with / (which is always floor division on a BitVec) and 2**x with 1 << x but that's more or less it (besides adding constraints to the solver on output and the loop instructions ofc). Though for me, the initial solution it found was not the lowest (my input had two different possible solutions). z3 actually even has Optimize() instead of Solver() and then you can minimize(a) to make sure you find the lowest but that was a bit slow for me (though it seems to have worked for other people). I just let it find all solutions (by continuously adding "a != solution" as a constraint) and then chose the lowest. Also, z3 technically is an SMT (satisfiability modulo theories) solver, not (just) a SAT solver. That's why it can also solve equations with proper integers without a fixed bit size and stuff like that. Actually, it can even find functions that satisfy given constraints.

Mine was a pretty awful bruteforce solution that somehow worked, but I recognised that my reversed outputs would "roughly" increment as my A register got larger, and so using a binary search to find the approximate region of the correct answer and then iterating in chunks of descending size as I got closer to the input program got me the answer in sub 4 seconds (Python). Disgusting, but it worked :D

I am not a speed coder, but I didn't even bother to write code to parse input, I just manually introduced the variables straight away

Try A=0...7 for your program and see which values output the last number of the program. Try those (recursively). Shift them 3 bits to the left, and then combine them via OR once more with values 0 to 7, and see which produce the second last number of the program, and so on. You will encounter some dead ends and then the recursion backtracks, but in the end you will have a number (at least one) of candidates for A that produce the desired program. Pick the smallest one. The code is not very long as it uses the run/execute method from part 1.

Was a nice journey this one (I made a walkthrough video about my solution). Had a couple of insights after decompiling the program which turned all operations into bit operations ('left shift', 'right shift', 'and' and 'xor', modulo 8 is just 'and' 7 and division by '2 to the power i' is just 'right shift i'): - The input value has to be 3*instructions.length in terms of bits (so 48 bits long) - The program runs basically a loop until the output value (new value of 'a' after one loop) is zero - Each step at most uses the 10 least significant bits of value a, however to yield a zero output it's possible to only try 8 different values. - The outputValue of each loop has to match up with the required inputValue of each loop to yield the expected output string. So a basic DFS or BFS can be done by starting from the end of the instruction list and working your way backwards to the start, each time left shifting your value with 3 bits. For each instruction you only have to do at most 8 iterations to match 3 bits of input. Doing this the code runs in less than 50 ms.

Abu Bakar Al Bagdadi Is Dead

I wrote the inverse of the instructions. One instruction in the loop needed an operand that wasn't yet resolved, but only 0..7 give different results, so i just did a dfs on that. I got 62 possible answers and the minimum is the right answer. Too bad it took me 2 hours do it :D JS screwed me a bit. I don't usually use it, basically only for AoC, so I didn't know xor casts to 32 bit integers. Luckily I noticed it quickly enough. Btw the divisions are actually right shifts by the combo op.

My bruteforce from 7 hours ago is still running

Interesting approach. I just printed first ~10k outputs and tried to spot the pattern. If you look at the first number in all outputs you can see it creates a sequence that repeats every 1024 (I assume this is the case for all test cases). The second number in all outputs appears at 8th position (for reg A = 8) and follows the same sequence but every number is repeated 8 times (you need to skip the first element for the first occurrence in the sequence, not sure why :D). The same for 3rd number in the output. Starts from the 8*8 (reg A = 64) and follows the sequence when every number is repeated 64 times. And so on. To find the answer you have to create a number in form: a15 * 8^15 + a14 * 8^14 + ... + a2 * 8^2 + a1 * 8^1 + a0 * 8^0 and put it as a input for the program (testing even very high number is very fast). You have to find the a15 that gives expected last number, then to find a14 that gives the second last number and so on, up to the a0.

For the 2nd part there are some tricky cases if you go for the wrong strategy. I also initially went for a strategy which keeps track of only the fronts of the pile of boxes instead of all of them, but it's very annoying to handle cases with a '.' between two boxes in your pile.

I've tried using z3 too, but I am so bad at it I ended up doing bitwise brute force as everyone else :D

I saw the every three contiguous bits of A maps to each output fairly early on, just didn't expect that to be brute forceable (laughably so - the sample space really grows small).

Was stuck in part 2 way too long, Thanks for the explanation

How did your program work when you didn't clear the _from correctly? In the case where we find a new strictly lower distance it should be cleared, no? Edit: saw the end bit but still not sure. Why is it true that the first time you visit a node is the best way to get there?

Watching this while drinking a big glass of LLM tears. Yummy. I hope this trend continues!

interesting, i had the same answers as you. I actually thought the difference between bfs and djikstras is exactly that the first time you reach a new node it doesnt have to be the cheapest way to reach it.

Amazing stuff. Congrats.

Sick work man. That part two was tough imo

Bro whats the final answer which we have to submit

Clearing the set in `from_` is actually important! My input breaks without it. The case in which it breaks is at an intersection. First, the node at the middle of the intersection is visited while going up with some distance X. While visiting the node, the same node but facing to the right is added to `dists` with a distance of X + 1000. Later on, the same intersection is approached from the left. The middle node while facing to the right can now be visited for less than X + 1000.

Great! For the first time I made <1k rank 322 for part1 but got stuck miserably for part2 😅

Great work! Amazing how your head keeps track of it all, and manages to explain what you're doing. I spent all day debugging to no avail, but made great visuals!

Great respect for you sir! Even explaining your thoughts while you’re at it at this speed is incredible.

4:08 you could have just put a box in the empty space and put the robot in the box it's next to. Tricky but not too tricky

Sadly completely stuck on part 2 after many hours. My solution solves the small test puzzle but not the larger one. I’ll maybe have another look later.

I was so happy to see you in second last night.

Congratulation !!! Pretty funny to see you arrive late today and finish a the 2nd place for the part 2 ahaha

Congratulations! 🎉

Hey Senior AI engineers! Looks like your LLMs not that smart ha! BURN IN THE DEPTHS OF THE FLAMES OF HADES!!! HA HA HA HA HA!!!

That was cheesy 🍕🧀 but very quick thinking!! I just printed after every second (with some delay to get down to 60fps) and just quickly keyboard interrupted when I saw the tree. Definitely not as fast but still very satisfying😄

congrats man. love your vids

sick

27:08 - afaik sets are not ordered. But, I was using sets for each step (I can't think of a scenario when one coordinate is added at one step, then tried to be added after some steps. So, you have the robot, then you have a set of boxes which need to move, which are adjacent to the robot, then set of boxes which need to move and are adjacent to first set of boxes, then set of boxes adjacent to second set and so on. And then added these sets to the list, so I could have order. It doesn't matter in which order you "process" boxes inside a "set", if they are "same distance" from the robot, but it makes sense to process sets one after another.