Only once you know for a fact that a better solution is possible can you actually think of that solution.
Without that piece of information, the brain just comes up with reasons why the score is already optimal.
If nobody had gotten to the score of 180 before me, I couldn’t have thought of any faster way of solving this puzzle. My friend then beat me with 148 using my technique, forcing me to find one last cycle. It took me hours, but I got the score down to 156, and then very quickly down to 149. Once I realized that I had used a different solution, I also realized that the solution that my friend picked could not be optimized further, but mine could. It was crazy to realize that there were in fact two entirely different ways to reach 180. It wasn’t until we talked about it that we realized that we had used different solutions. After literally days of thinking about this problem I managed to think outside the box and match my friend’s score of 180.
#INFINIFACTORY INTERFACE HOW TO#
And wondering how to get over there, my friend somehow got to 180, telling me “I think this one is optimal.” The score seemed unreachable. Except there were some people over on the left of the histogram. On the second puzzle in the game, which serves as a kind of tutorial, the only possible score is 240. You can’t think of a solution until you know it’s possible
#INFINIFACTORY INTERFACE CODE#
It is simply faster than whatever code they compared it against. Even the code in our standard libraries that’s maintained by some of the best programmers and that’s used by millions is slower than it needs to be. I can now say for a fact that a lot of code out there is far from optimal. Almost every single time that I thought the limit was reached, we broke through it soon after. (the game is still in early access) But if it hadn’t been for that, I wouldn’t have been surprised if we could have optimized this further.
#INFINIFACTORY INTERFACE PATCH#
At that point a new patch hit that changed the level slightly so that our solutions didn’t work any more. My friend and I have literally had cases where we went from a score of more than 500, where my friend thought that my score was impossible, down to a score of 202 for me, and 200 for my friend which put us completely off the charts. So after another hour of head-scratching about how you could possible achieve this you find a way to do it, and lo and behold it the wins are far bigger than expected, the new score is 310! And the next day your friend comes back with 290… It doesn’t seem possible, and it’s not even clear that this will buy this much of a score improvement, but it’s the only thing you can think of. You’re thinking the only way that you could possibly achieve such a big jump is if you could somehow combine these two different parts of the algorithm, so that they can share this one part of the work. So now you need to think outside of the box. Soon after your friend will beat your score with 320. After an hour of staring and trying different things you find a small improvement, and your new score is 332! Proudly you tell your friend that you beat their score. The score is just the number of executed instructions) What follows is a bunch of head-scratching about how you could possibly get any more cycles out of the algorithm. Let’s say my score is 340 and a friend beats me with a score of 335. When you’re competing with another player, they will probably find a way to beat your score by just a few points.
Those solutions were always far from optimal. After a lot of work I would usually arrive at an “optimal” solution that puts me in the best bracket on the histogram. If my solution would fall on the right of the bell curve, I would optimize it until I was on the left. Shenzhen I/O shows you a histogram of all the scores that other people have reached. There is only code that’s faster than the code that you’re comparing to From playing that game, here are a couple lessons: 1. Competing on the leaderboards for puzzles is enormous fun. It’s great alone, but it’s even better if you have a friend that’s playing at the same time. It’s just about coming up with clever tiny algorithms and micro-optimizing the heck out of them. It distills programming down to the fun parts, removing the inertia, self-inflicted complexity, overhead, uncertainty and drag of real programming. In case you haven’t heard of it, it’s a game about programming micro-controllers.
0 kommentar(er)
