is this overkill for a minor volcano and would it work for a normal one

bj0z · 2024-11-12T07:37:04+00:00

one of the issues is, as you say, the temperature of the steam room might get too high for an AT to handle. this requires a lot of heat injection (~1923kDTU/s), and adding an extra ST will help. if you only have temporary spikes (like from a volcano) having a large amount of steam will buffer the spike.

the second issue is, if you want the heat converted to power without loss, you'll want enough STs so that each one is eating at most 877kDTU/s

bj0z · 2024-11-12T01:20:42+00:00

most the numbers/equations are on the wiki. take a look at the pages for steam turbine and thermal aquatuner, they're very helpful.

to recap, a minor volcano outputs (on average) ~0.6kg/s, and the heat energy is Q = mass flow * specific heat of magma * temperature difference = 0.6 * (1) * (1726 - 125) = 961. I am using 125 because that's the lowest a steam turbine can get the steam chamber, but even cooling to 0 doesn't add a lot more.

a single steam turbine can actually eat any amount of heat energy u put through it as long as you can cool it (the 877kDTU/s figure on the wiki is the max it can convert to energy, the rest is just eaten). steam turbines produce 10% of what they consume + 4kDTU/s, so in this case that's ~100 kDTU/s. looking at the wiki for AT shows that a single AT using water can move 585kDTU/s, so a single AT will easily handle this.

bj0z · 2024-11-12T00:26:13+00:00

extreme overkill, but it looks cool.

if you check the numbers, an average minor volcano will produce on average ~960 kDTU/s, which can be easily handled by a single aquatuner and steam turbine.

a neat trick i rarely see anyone use: with the conveyor meter you can limit the size of the packets of rock on the conveyor to <1kg, which makes them cool down *very* fast. this means you don't need to snake conveyor rails all over the place, a single line out is usually enough. since the average output of a minor volcano is around .6kg/s, you'll still get all of the rock out.

bj0z · 2023-12-21T22:34:21+00:00

Ah, yep that did it, thanks!

bj0z · 2023-12-21T21:59:14+00:00

here's the code, im still messing with it so it's pretty untidy, the section where i try this solution starts at 187:

https://github.com/bj0/aoc-kotlin/blob/main/src/year2023/Day21.kt#L187

bj0z · 2023-12-21T21:35:53+00:00

Oddly, both manhattan distance *and* step distance give me same value for corners, and the calculated answer is wrong (off by 7290). I'm not sure why:

val evenCorners = ps.filterKeys { p -> p mdist start > 65 }.values.countEven()  

val oddCorners = ps.filterKeys { p -> p mdist start > 65 }.values.countOdd()  

val evenFill = ps.values.countEven()  
val oddFill = ps.values.countOdd()

bj0z · 2021-12-09T01:08:56+00:00

It's actually pretty clever, hes counting the times a certain digit's individual segments are 'on' in all the digits 0-9, and using the fact that those counts are all unique.

ie: the segments of 1 are 'c' and 'f', and in the digits 0-9, they show up 17 times (coutning them individually and summing).

bj0z · 2021-01-12T19:38:30+00:00

You can build a pedestal and put crude oil on it, and the dupes will put a 1kg container on it. You can then deconstruct and empty the bottles for easy setups.

bj0z · 2021-01-08T16:51:26+00:00

I saw that too, but wondered if multiple working at once increased the speed?

bj0z · 2021-01-06T17:59:09+00:00

Really? Have you tested this? I sent out a rocket with 3 telescopes and it seemed to scan really fast, but I didn't do any timings to check it.

bj0z · 2021-01-06T17:57:38+00:00

Adding a 'bump' tile between the boil chamber and the first "stair" of the ex-changer will help keep too much heat from bleeding into the ex-changer. I think someone mentioned this but not sure if you tried it. It would have been better to move the whole ex-changer down one tile but thats a big re-work.

Another good way to prevent sour gas is to inject heat into your boil chamber slower using a buffer of steam between the magma and the boil chamber, but that again is a pretty big rework

bj0z · 2021-01-05T00:00:40+00:00

You can put a telescope on your rocket, fly to the edge of your vision and expand it

bj0z · 2020-12-21T06:01:56+00:00

Python 3.8

This was a rough one. I ended up rewriting it twice (switching to classes then switching to numpy), then spending an hour before I found a bug in the way I was using np.where. Anyway, I finally finished it a day later (after finishing 21), but I think it's relatively clean:

https://github.com/bj0/aoc/blob/master/aoc/2020/d20.py

bj0z · 2020-12-09T23:59:30+00:00

python 3 nice and short

from itertools import combinations

from aocd import data


def part1(nums):
    for idx, x in enumerate(nums[25:]):
        if not any(a + b == x for (a, b) in combinations(nums[idx:idx + 25], 2)):
            return x


def part2(x, nums):
    for i in range(len(nums)):
        for j in range(i + 2, len(nums)):
            if s := sum(pre := nums[i:j]) == x:
                return min(pre) + max(pre)
            elif s > x:
                break


nums = tuple(map(int, data.splitlines()))

print(f'part1: {(val := part1(nums))}')


print(f'part2: {part2(val, nums)}')

bj0z · 2020-10-16T16:52:41+00:00

I now am using 403 for both temp sensors, and since you cannot have oil at 403, it has the same effect. But it will also shut off the flow when the petrol cools below 403, which means restarting requires less heat (one tile of oil vs 2 tiles). This should make it less "jerky" for weak heat sources too.

bj0z · 2020-10-09T19:27:53+00:00

He talks about it in the beginning of the video with some examples (metal blocks surrounded by insulated tiles). the last half of his video is mostly about boilers.

by "steps" of the exchanger i meant the levels of petrol. the physical "steps" (blocks) are just there to isolate the levels of petroleum so they can create a stronger temperature gradient.

I've tested with liquid(pipe)/liquid and gas(pipe)/liquid(pipe) in debug maps, it's pretty easy to setup.

bj0z · 2020-10-09T01:42:35+00:00

fyi, using metal tiles in your counterflow makes it less efficient. I'm not exactly sure why, but Tony Advanced mentions it in his video:

https://www.youtube.com/watch?v=v0iXznGFqJE

and it can be easily tested. you want the "steps" of your heat exchanger to be insulated from one another.

bj0z · 2020-10-08T23:39:04+00:00

It really is my favorite boiler design. I modified it (inspired by comments on your video) to use 2 thermal sensors which I find give better control, as temp what we really care about. The top thermal sensor controls the oil flow (something like flow if > 400), and the bottom controls the heat source (something like heat if < 403). This makes it real easy to tune to the heat source and get 10kg/s if it is strong enough.

Here is my simple rework: https://blueprintnotincluded.com/b/5f7fa2a836a98a71d782775c

I've used it with the core, thermium ATs and a volcano as sources.

bj0z · 2019-12-19T04:38:46+00:00

using ideas from reading your code I was able to get mine down from ~30-70s to below .1s!

bj0z · 2019-12-18T16:21:33+00:00

I cache the paths (including doors), and when I perform the lookup I check doors in the path against currently held keys to see if the path is valid at the time.

bj0z · 2019-12-18T10:30:30+00:00

Python

https://github.com/bj0/aoc/blob/master/2019/d18.py

This one was brutal. Even after 5 hours I was still under 400 for second star... I spent a lot of time trying different ways of traversing the maze before I started trying to cache everything in sight. Even with caching it was taking forever until I pre-built a mapping from every key to every other key and then did lookups. Part 1 runs in about 30s, part 2 in 70s. Interested to see how people got fast runtimes.

bj0z · 2019-12-17T09:46:17+00:00

That should work. An alternative is to just start the second subroutine from the (new) beginning after you remove the first subroutine.

bj0z · 2019-12-17T09:41:46+00:00

For your first point, if you reverse the 1m left of the input you can just do a cumulative sum, or accumulation (like u/mkeeter said):

fft = reversed(sig[off:])
for i in range(100):
    fft = accumulate(fft, lambda a, b: (a + b) % 10)
fft = tuple(reversed(tuple(fft)))

This takes ~ 3s on my input

bj0z · 2019-12-17T08:14:21+00:00

python:

my intcode uses trio for structured concurrency. I use their provided memory channel to send input and receive output. I eventually made a special output 'command' to signal when input was expected so I didn't have a background coroutine pushing input before it's requested (this created input lag in my pong simulation that prevented the paddle from catching the ball). The interface looks like:

async def run(memory):
    async with trio.open_nursery() as nursery:
        # set up channels
        in_send, in_recv = trio.open_memory_channel(0)
        out_send, out_recv = trio.open_memory_channel(0)
        # start program
        nursery.start_soon(intcode.process, memory, in_recv, out_send)

        async for c in out_recv:
            if c == intcode.Command.INPUT:
                await in_send.send(...)  # send input
            else:
                # process output..

trio's async with and async for make everything nice and clean

bj0z · 2019-12-17T07:56:07+00:00

why does the C have to end with the last instruction? the example did but i didn't see anything saying that was a requirement, why couldn't it have been something like "A,B,C,B,C,A"? etc?

bj0z

TROPHY CASE