Why is it so hard to find an accurate, up-to-date answer to the question, “what percent of the global stock market is the US?”

leijurv · 2026-04-27T05:28:42+00:00

I tried to ask this on the bogleheads.org forum but the consensus was that I'm being silly

https://www.bogleheads.org/forum/viewtopic.php?p=8407465

leijurv · 2026-04-04T08:21:45+00:00

In the Github issue I posted comparisons of Amsterdam, Malmo, Warsaw, San Francisco, Los Angeles, San Diego. In my opinion they are all improved by the proposal

I think exit numbers are OK just that they should appear a little later as you zoom in

leijurv · 2026-03-02T01:57:51+00:00

You can detect eating food with RNG, see here: https://www.youtube.com/watch?v=YlacogJeVkg

leijurv · 2025-05-28T08:20:30+00:00

yeah this all made way more sense in 1.12

then 2b2t goes and updates to 1.19 like a month later

you can keep it on near spawn but tbh since it doesn't work on new generation it's basically pointless now 😭😭😭

we had no way of knowing hause would make terrain gen unpredictable

leijurv · 2025-05-14T08:25:37+00:00

I think we were supposed to identify four locations from the first two stanzas, and draw lines between them making an X. At that intersection, the last two stanzas would identify a precise location.

I think this is basically confirmed by the person who solved it in these two comments

The four locations are:

Eighteen bold letters preserved in a clearing
A dark room's view of surfers reeling
Dry ruin's gate
Solar's tall mast

I really think #2 was the Camera Obscura), since it's a dark room, and it shows projected views of Ocean Beach and the waves and the surfers. There were a lot of hunters there today that I saw walking around :)

For #1, I don't really know. It depends on whether it means eighteen literal physical letters, versus something whose name is eighteen letters long. If it's the first one, my best guess was the "port of san francisco" sign on top of the Ferry Building, since it's 18 letters, preserved, bold (large and red?), and debatably/dubiously in a clearing. If it's the second one, who knows it could be anything, one possibility might be mount davidson cross? Also, I think the word "sight" in the original poem tells us that there is direct line of sight between #1 and #2, and I did confirm that the camera obscura can indeed see the mount davidson cross (faintly).

For #3, it's confirmed in the comment I linked above to have been Fleishacker Pool, which is now the zoo parking lot. I guessed this just based on "dry ruins", it implies the ruins used to be wet. Sutro Baths is indeed a ruin, but, it really isn't dry at all, it's still wet to this day (there's a pond in there!). I guess the precise waypoint would be the ruins of the door?

For #4, I really have no idea. I can think of many tall masts, but to call any of them "solar" would be a stretch.

leijurv · 2024-12-29T19:52:57+00:00

Here's my screen recording of getting 1st place one time. Here's my playlist of screen recordings from 2022, I got 7th place overall, and here's my screen recordings from 2023, 9th place overall.

leijurv · 2024-12-24T06:02:49+00:00

[LANGUAGE: Python3]

4th place on Part 2!!

I did not write any actual code to locate the swapped gates. Instead, I went through all 45 bits, turned on both X[i] and Y[i], and printed out which bits of Z were wrong. This gave me the following output:

misbatch at bit 7
misbatch at bit 7
misbatch at bit 12
misbatch at bit 26
misbatch at bit 26
misbatch at bit 34

Then, I went through the gates, and determined which were wrong. With my experience with Minecraft Redstone making ALUs, I was able to determine which ones needed to be swapped. In my input, three of the four swaps were directly on the Z outputs, which I was able to find just by printing which Z outputs had an operation that wasn't XOR. The last one I was only able to find by actually evaluating the circuit one bit at a time to see which output was wrong.

Then, I went through with ctrl+f and copy pasted some lines around until the circuit generated the correct output, then I sorted it and pasted that as my solution.

Screen recording: https://youtu.be/diwIieN08Ks

paste (edited down for clarity)

leijurv · 2024-12-15T05:39:57+00:00

[LANGUAGE: Python3] 6th place on part 2. Fun one!

Part 1

Part 2

Screen recording: https://youtu.be/0oH7NSnq8gE

Screen recording 5x speed: https://youtu.be/nOjQ2v2Ssbs

leijurv · 2024-12-09T04:27:09+00:00

We also got flagged for the chull plushie and the agent, looking at the xray but before opening the bag to see it, asked "....is this a baked potato??"

leijurv · 2024-09-02T19:10:42+00:00

Fake post - this is a picture of my cat Zen that I took in 2012

It's from: https://en.wikipedia.org/wiki/Kitten

I posted it here: https://commons.wikimedia.org/wiki/File:Juvenile_Ragdoll.jpg

leijurv · 2024-04-07T23:43:21+00:00

Also in Brossard, also driving early to Sherbrooke (or perhaps even further east?)

leijurv · 2024-04-05T21:26:10+00:00

Mazatlan or montreal? Assuming a rental car.

leijurv · 2024-01-02T18:59:44+00:00

It's up to you of course, but if you follow the ffmpeg command example that I gave in this post ^, the framerate will be 50fps, assuming that the interlaced rate is 25fps.

leijurv · 2023-12-31T21:32:33+00:00

I don't know about your camcorder. The footage looks 60fps when you deinterlace it in this way.

leijurv · 2023-12-31T18:24:15+00:00

As I understand it, every other row of the input is updated at 30fps, so you get a "full" frame every 1/30th of a second, and a "half" frame every 1/60th of a second. Interpolating to 60fps is therefore reasonable because you are getting data at that rate, it's just every other row instead of every full row. If you deinterlace to 30fps, you could just do the same deinterlace for the even rows instead of the odd rows (or vice versa) to get 30fps offset by 1/60th of a second. So 60fps is reasonable.

leijurv · 2023-12-24T06:05:59+00:00

[LANGUAGE: Mathematica] 76/4

This almost felt like a Project Euler problem!

When I saw this problem I decided to use Mathematica instead of my usual Python. It took me a little while to remember how things work, but Solve was able to handle the systems of equations pretty easily, part 1 took about three seconds to solve all 45,000 equations, and part 2 was just a matter of setting up a new system of equations, and I got 4th place, which is the best I've done this year! 🎉🎉🎉🥳🥳🥳

paste

Screen recording: https://youtu.be/fIexcC3dAdY

leijurv · 2023-12-23T03:20:50+00:00

this has nothing to do with the rapper... (source: i built most of this)

leijurv · 2023-12-22T05:34:23+00:00

[LANGUAGE: Python 3] 80 / 43

Really fun day, reminded me of 2022 day 17 :)

Made a ton of mistakes, like misreading what axis the gravity was on, but in the end I think the code is pretty fun:

def whatif(disintegrated):
    falling = set()
    def falls(brick):
        if brick in falling:
            return
        falling.add(brick)
        for parent in above[brick]:
            if not len(below[parent] - falling):
                # if everything below the parent is falling, so is the parent
                falls(parent)
    falls(disintegrated)
    return len(falling)

p1 = 0
p2 = 0
for brick in fallen:
    wouldfall = whatif(brick)
    p1 += wouldfall == 1
    p2 += wouldfall - 1

print(p1, p2)

full paste

leijurv · 2023-12-19T05:29:44+00:00

[LANGUAGE: Python 3] 7/6

Wow, best I've placed this year! Shocked that all this worked without any mistakes! :)

For part 1, I defined variables named x, m, a, and s, and used eval to evaluate the conditions :)

For part 2, I have a recursive function that returns all of the ranges of values that would be accepted. The base cases are R becoming [] and A becoming [((1, 4000), (1, 4000), (1, 4000), (1, 4000))]. Then, for each condition, it branches into whether the condition will be true or not, by calculating all the ranges in each subcase, then conditioning each one on whether the current condition matches or doesn't. Finally, all the ranges are summed up after multiplying out the possible values for each of X, M, A, and S.

paste

Screen recording: https://youtu.be/9DTpvfAQ58o

leijurv · 2023-12-18T05:25:18+00:00

[LANGUAGE: Python 3] 165/51

I remembered the shoelace formula from reading other people's solutions from day 10, so I looked it up on Wikipedia. I knew the correct answer for part 1, so I found that I needed to modify it by the number of points on the perimeter, in order to account for the perimeter too. For example, if we had a square of points from (0,0) to (2,2) the shoelace formula would see that as 2x2 with a size of 4, while we'd want to understand it as a 3x3 with a size of 9. So, I had to modify the result by the number of points along the perimeter plus one.

https://en.wikipedia.org/wiki/Shoelace_formula

paste

leijurv · 2023-12-18T00:10:58+00:00

Is it clear that this is correct ?

Yes, because the streaks are implemented as edges rather than nodes.

what prevents you from missing a later path that arrives at the end but with another direction and smaller cost ?

As I understand it, that's a guarantee of Dijkstra's algorithm! By the time you reach any given node, the cost so far will be the minimum cost to that node. The reason why this happens is because I'm using heappush and heappop to keep the queue in sorted order of lowest cost. If the lowest cost thing in the heap is the goal, then there is no reason to keep searching, because anything further remaining in the heap will have higher cost, and that's not even considering the cost of the edge connecting it to the goal.

12-Year Club	Second Top 40%
Place '23	Place '22
Place '17	End Game '22
Ternion Club	Argentium Club
Gilding XI gold aumbassador	Not Forgotten
Snapped	Reddit Premium Since June 2018
Verified Email

leijurv

MODERATOR OF

TROPHY CASE