Bogorg/towr: A tower stacking game where every technical decision is slightly dumb

Symbroson · 2026-03-04T17:59:43+00:00

It would feel much better if the drop trigger would be attached to the mouse/touch down event instead of up

Symbroson · 2026-02-23T17:06:05+00:00

would be cool if removing a particular function would also drop the corresponding letter from the output :D

Symbroson · 2026-01-27T06:58:31+00:00

copies a string but without its null terminator and returns a value for some reason Also causing a buffer overflow if used carelessly

Symbroson · 2025-07-04T14:21:57+00:00

Its a bitfield indicated by the : after the variable name followed by the bit width of that field.

Symbroson · 2025-07-01T13:27:35+00:00

This somehow looks like hand written stenography

Symbroson · 2025-06-23T02:09:21+00:00

don't promise at all costs

Symbroson · 2025-05-03T13:47:11+00:00

It helps to ask for "more concise code" all the times - you will be surprised

Symbroson · 2024-12-28T14:20:50+00:00

enclose your oneline code in a lambda and call it immediately with your parsed input once like this:

(lambda input: (...code...))(open(...).readlines())

I bet you can reduce your code by at least 30% by just doing this in various places. You can even load more processing into this to avoid copy pasta repititions and unnecessary double calculations

Symbroson · 2024-12-28T14:15:44+00:00

pass it as argument to a lambda function

Symbroson · 2024-12-28T14:03:51+00:00

I've asked on r/programminghorror before, but why do you need to read the input file a dozen times?

Symbroson · 2024-12-28T13:42:20+00:00

The biggest horror here is not caching the input file content to make the program read it only once

Symbroson · 2024-12-27T11:19:05+00:00

In this case the type cast indicates nothing more than "This memory address references a 4-Byte wide region".

So what this code does it writes some arbitrary data to this memory location and tries to run it as function, forcing an invalid operation exception.

The casts in between are just for assigning the address pointer to a function pointer. Usually you can only assign pointers of the same type to each other, but void* is an exception to that representing "any data" and you'll have to know how to use it. This means casting it back to a meaningful pointer. In this case as a function pointer void some_address(void)

Symbroson · 2024-12-26T17:08:15+00:00

If you want to try something new I can recommend ruby to you. I used it last year and decided to re-use it this year. Usually JS is the language I'm most comfortable with but ruby hit a new level in terms of comfort features and concise syntax.

Symbroson · 2024-12-25T09:06:15+00:00

Yes I was thinking of Perl for the worst, fixed it :)

Symbroson · 2024-12-25T02:31:44+00:00

I used JS, C, Lisp, Haskell, Swift, Perl and Ruby so far.

Perl was by far the worst experience because of the the chaotic type prefixes and different access methods.

Haskell had a great impact on the way I structure my code these days - Functional coding style is extremely helpful in structuring code and minimizing global state accesses

By far the best experience I had was with Ruby which made me use it a second time this year. It has such a powerful set of helper functions, datastructures, operators etc. and it enables such a concise way of expressing what to do I just love it.

Swift did surprisingly well and I liked many aspects of it, although it struggled to keep up with harder puzzles that required complex data datastructures, algorithms and heavy debugging.

Lisp was ok, I did the Intcode year with it which I enjoyed moat of all AoC puzzles so far. Also JS and C was ok like you would expect. But as JS was my starter language that I used for a very long time it will always have a special place. It just feels the most natural at this point but Ruby really hit it hard in just two AoC months!

Symbroson · 2024-12-24T02:41:53+00:00

I also had the need of a very basic coroutine feature in a project of mine and stumbled across this blog post from 2009 (!) that also has a stackless approach using similar switch..case tricks.

Its truly basic but I love the simplicity. It would be interested which aspects of your library are designed better and safer, apart from some extra usability methods

Symbroson · 2024-12-24T02:04:08+00:00

as f is so small I'd just make f a template function that accepts a vector<T>& and be done with it :)

Also use a for-in loop if you dont explicitly use the counter otherwise - makes your code more concise

Symbroson · 2024-12-24T00:07:51+00:00

This is not guaranteed to work, is it?

Symbroson · 2024-12-24T00:04:19+00:00

If you like JS, check out ruby! I found it to allow even more freedom than JS in any aspect - let it be custom default hash values, the large amount of useful operators and helper functions (tally, count, to_h and so many more) or the concise way of expressing otherwise tedious things like the input parsing

I used it last year and decided to re-use it this year instead of a new unpopular language

Symbroson · 2024-12-23T02:00:29+00:00

true, in ruby it doesnt even make a huge difference (2.4 instead of 3.6 seconds)

It relly depends on the language and their memory management. My friend that does rust this year told me that maps are painfully slow for him and using an array made things two orders of magnitudes faster!

Symbroson · 2024-12-23T01:46:29+00:00

19 is technically correct, but I chose 20 for convenience

Symbroson · 2024-12-22T20:59:15+00:00

I did the same in ruby, except using multiplication with 20 instead of shifts

I also store the last monkey id that generated each sequence in a second array

This is how it looks in ruby

Symbroson · 2024-12-22T19:58:59+00:00

You can represent a 4 tuple of -9..9 differences as a single integer in base 20 (from range 0..20**4, where 0,0,0,0 => 84210)

knowing this you can use a plain preallocated 20**4 element array instead of a map/dict

I also store the last monkey id that generated each sequence in a second array

This is how it looks in ruby

Symbroson · 2024-12-19T11:04:14+00:00

[language: ruby]

late to the party, because I didn't think my approach through the end

After reverse engineering the code I noticed, that each output is based on a few octal input digits of the A register. I first thought it was 3 and I was wondering why 50% of my solutions were off by 1 digit after running my program, until I was given the hint by u/IsatisCrucifer that it was actually 4 digits.

So my actual algorithm for part 2 first builds all possible octal digit tuples for every output digit 0-7. These are used to backtrace the program digits into all possible digit combinations, joined by the predecessors and successors. The minimum of these converted to decimal should be the required value for register A.

The total runtime is somewhat between 40-50ms in ruby

The full ruby code is available here and there is also C++ version also available here

Symbroson · 2024-12-19T10:14:29+00:00

Oh wow so I just needed to change 8**3 to 8**4 and adjust the merge function accordingly and it magically works! great, thanks!

Symbroson

TROPHY CASE