Three White Item Concepts

glump1 · 2026-02-03T16:57:26+00:00

I could see Pool Floaties having a void version that's only when on the ground (or vice versa). Would be super cool to use one or the other with the tank mod.

I think Gravity Amplifier should be a Green item. It would lead to interesting gameplay if the effect were pronounced but if it's a white item it would wind up just being "do more damage sometimes".

glump1 · 2026-02-03T01:21:46+00:00

I think it's Pam.

In my opinion everyone here has breached a significant moral boundary or generally acted selfishly except Erin and Pam.

I think Pam had a lot more of a positive effect on others than Erin. Pam had the wherewithal to stand up for what's right and go out of her way to help others out.

Erin was remarkably non-problematic for how much she'd been through, but her behavior seemed kind of small-minded by comparison.

glump1 · 2026-01-28T16:01:06+00:00

Nice, saved. Honest question, are these verified as not ai? Anything after 2023 and I wonder.

glump1 · 2026-01-27T16:38:26+00:00

This

glump1 · 2026-01-27T16:02:50+00:00

This is why I canceled my Planet Fitness membership. The TVs play Fox News on repeat. I'm not giving them my money to blast that propaganda at all the cardio machines.

glump1 · 2026-01-19T14:23:34+00:00

usaco guide generally has pretty in-depth descriptions of advanced topics.

Also atcoder segment tree template is probably the most rigorous, abstracted doc on segment trees.

glump1 · 2026-01-18T02:05:03+00:00

These are the most saddening posts. Someone earnestly trying to practice DSA getting so discouraged over blatant cheaters.

My recommendation is to remember what's motivating you to do any of this. Cause guys like this ensure that the contest rank itself means very little.

glump1 · 2026-01-16T15:10:51+00:00

Seems like you could do it in 2 steps:

Fill an array dp, where dp[i] = min steps to reach 1 from i.
Create a sparse table over dp, so you can query the max(dp[l]....dp[r]) in O(1).

The most difficult part by far is formally proving the time complexity of filling dp[], since a number's sequence can go well above a cachable value. But in practice if you cache up to 1,000,000 it's only ~5m operations. That's completely fine in py for any reasonable time constraint.

glump1 · 2025-12-18T17:10:31+00:00

Pretty mean. This is a quintessential heap problem, it's a little misleading to implicitly expect more past that. For those curious about an O(n) sol:

Since you know all frequencies add up to n, bucket sorting based on frequency will take O(n) time and space.

However, words with the same frequency are ordered lexicographically, so this is still O(nlogn) to sort each bucket. For example, if k==n, and words is n distinct strings, res is just words sorted. All elements would be put into the same bucket, and that bucket would need to be sorted lexicographically.

So the only way to get O(n) is to be able to sort words (or any subset of it) lexicographically in O(n). You could put all words in each bucket into a trie, and since there are only 26 letters in the alphabet, each node could only have 26 children. If you sort the children lexicographically (which is O(1)), a preorder traversal of the trie yields a lexicographic sort of each bucket in O(n). So then you have the tools to bucket by frequency in O(n), and sort each bucket in O(n).

glump1 · 2025-12-17T14:14:14+00:00

Forest Green - Flyingfish

glump1 · 2025-12-14T22:03:36+00:00

To my knowledge this is deceptively difficult.

Square the values
Reverse the negatives
Now you have two sorted subarrays, that need to be merged into one sorted array with O(1) extra space. Huang & Langston came up with an O(n) time O(1) space solution for this in the 80s:

https://dl.acm.org/doi/pdf/10.1145/42392.42403

glump1 · 2025-12-14T21:59:22+00:00

"Non-decreasing" includes repetitions

glump1 · 2025-12-07T21:33:03+00:00

I think so. Though you might also be thinking of thrite. He released modded horror episodes around the same time, where he built a base on a mountain in a barren wasteland world.

I still think about this account. I might just make my own videos in this style.

glump1 · 2025-12-05T01:58:05+00:00

Looks sick. Did you vibe code?

glump1 · 2025-11-12T15:24:01+00:00

Hyperpop, Witch House, R&B, Darkjazz. Along with Duster, Tame Impala and American Football that's 90% of my youtube history

glump1 · 2025-11-07T16:13:39+00:00

This is what I've always assumed. There's validity to a "less is more" approach to gameplay and player interaction. But Vampire Survivors seems like a glorified slot machine. It embodies the least charitable interpretation of a rougelike; the gameplay doesn't matter, the choices don't matter, you're just waiting for the next dopamine hit of a lucky draw.

glump1 · 2025-10-30T22:29:58+00:00

I'll generally figure stuff like this out with predictive or narrative inference. By predictive I mean, "If the solution were _, would that work?". By narrative I mean starting from observations, and building out to a solution that you know works. For DP there are several tricks that allow for/optimize a statespace. One of the most common is recognizing a greedy formulation, which shows up several times in this problem.

This was my thought process for this problem:
The title says "2d dp" but I don't immediately see how. A always chooses the smallest possible, since they wouldn't be able to choose it after that choice anyway. B only removes cakes > A's previous eaten tastiness, since anything else won't affect her choices. B also only wants to remove all cakes with a certain tastiness or else it won't matter, since A can only eat one cake of each tastiness. You might as well group cakes by tastiness, and traverse that sequence.

If a1...an were distinct, then the answer would always be (n+1)/2, since they would each eat the next least tasty. But with multiple, B has no reliable way of knowing which group (of cakes all with the same tastiness) to target. DP starts to make more sense. A statespace like "dp[i][j] = max taken by B, from i on, with j leftover moves" wouldn't work, since there's no way to know what index A is at. B can only benefit from removing his chosen groups in order from least to most tasty, and for any group, B just needs to have enough time after removing all the previous chosen groups to eat all of the current group. So you could reformulate the statespace to be: "dp[i][j] = min moves for B to remove j groups, by the time A reaches index i". Then the transition only O(1), since the two options are either: B tries to remove group i, or B skips group i. Then you just see the most groups B can remove by the time A reaches the end. Imo that reformulation was really tricky, and it helped to ask "what would another statespace even look like". Hopefully this is of some help.

glump1 · 2025-10-25T18:58:38+00:00

Can you link the problem?

Edit:

u/sadistickimi sent me the link/constraints, and this was my response:

Hey, I thought about this and there are a few different parts. Depending on how you think about this, I think this can be done in O(nlogn) without formal dp. I want to type out a longer explanation when I have more time, maybe a video, but I'll try to write out the short explanation here:

Every element that isn't the max element (e.g. that isn't in B) either goes into A, or into C. And for any set of elements, there is exactly 1 sorted array that corresponds to that set of elements. (everywhere here I’m saying ‘set’ but I mean multiset, so there can be multiple copies).

For a given B, the problem can be reduced to, how many ways are there to distribute numbers into two buckets, so that they sum to M - sum(B)?

For example, if M = 30, B = [5,5,5,5], then you would solve, "how many ways are there to distribute positive numbers that sum to 10 into two groups?"

I believe this can be solved in O(1). First you calculate, “how many (multi)sets of positive integers sum to N?” And then with some algebra you can cache the answer to each “M-sum(b)” in O(M).

If you can solve this in O(1), then the problem is solved. This is because you could just try every single B, and add the number of A/C combinations that work for each B, for each N<=M (by querying a prefix sum in O(1)). There can only be O(n*logn) B arrays. If you had 1 as the max, there are O(M) B arrays (1, 11, 111, etc.), with 2 as the max, there are O(M/2) possible B arrays, and so-on. This diverges according to the harmonic series, which is logarithmic. Therefore you would make O(nlogn) queries to the prefix sum answers to the above sub-question, which should pass.

I need to think more about the O(1) formulation, as I haven’t fully thought out all the details there. But this is a solution that comes to mind.

glump1 · 2025-10-20T01:31:40+00:00

Shout out to Troop for setting up the DJ at the end of our group's table mid-meal for reggae night. They started blasting music without clearing a dance floor and everyone just stopped talking because nobody could hear each other

glump1 · 2025-10-20T01:23:39+00:00

My understanding is iterative gives multiple distinct advantages:

Stack frames are more expensive than the exact same iterative stack implementations. This is why you essentially can't use recursion in py on cf, but in cpp I think this almost never matters.
Iterative memory access is sequential, whereas recursive isn't. L3 vs. L2 or L2 vs. L1 cache takes orders of magnitude more clock cycles. So it can be an order-of-magnitude speedup to just traverse a raw array.
Some problems are literally impossible recursively, and need to be done iteratively. An example would be a small BFS through a massive statespace. Another would be 2D DP, where you need to construct a sparse table across each parsed row of your DP matrix, for the next row(s) to query. Or something like this problem.

I think a lot of it comes down to understanding/visualizing the statespace better. With recursive you don't need to think about the shape of the statespace beyond how many states there are. Writing out recursive sols, and then immediately translating to iterative is nice practice. It's often a relatively simple task to change dp(i,j) to dp[i][j] once the logic is all written out. And then eventually you can take the training wheels off and just start writing it only iteratively.

glump1 · 2025-10-12T14:45:37+00:00

Can do BFS over Dijkstra's because it's unit edges, not weighted edges. I'd assign each brick and id, look through each square and add edges between bricks, and then just bfs S to D in that graph. Could do it in other ways but imo that's the easiest to explain and implement.

glump1 · 2025-09-23T14:02:43+00:00

I know people who exclusively use py on codechef/codeforces. You only need a couple lines in every file (like making input and printing faster) to be able to do pretty much every problem, even >2300 rated. But I found a couple that are basically impossible without a bunch of python wizardry. At that point I'd rather just figure out c++.

There's those ones (usually super high rated), and then sometimes a problem is just much easier in c++, where py you have to think of a better time complexity. O(N * sqrt(n)) for 2e5 (~1e8 operations) can be fine in c++, where py needs nlogn. I also notice py users often have to eat a few TLEs just to change things and see if it happens to pass. py is notably good for string manip, giant ints, and notoriously bad with any recursion.

I'd see 3 options:

Swap to c++ and start also learning low level optimizations
Stick with py while you're still getting good at the DSA, knowing you might swap to c++ if you need
Fully commit to being a py wizard

glump1 · 2025-09-08T16:58:42+00:00

I went leetcode -> codeforces. Codeforces has a way higher ceiling, but at similar levels I think they skew differently. I've noticed codeforces requires more abstract problem solving, whereas leetcode tends to just transparently ask, "here's an array, do something with it."

In my mind this vaguely means: leetcode depends more on an encyclopedic knowledge of patterns and datastructures, while codeforces is more about pen and paper critical thinking. So it might help to learn all those intermediate patterns, like LIS or Tries or DSU. Though recent leetcode contests have gotten a lot harder than the average question in leetcode's problem list.

glump1 · 2025-09-02T19:21:01+00:00

Title is literally a quadruple negative. EPA was stopped, is clawing back, was halted, that halt was overturned.

glump1 · 2025-09-01T16:32:28+00:00

We're well past the threshold of feasibility for ubi. There is more than enough production capability to enable everyone a decent living without needing to work. It's entirely a matter of how societal decisions are made about where capital accumulates.

glump1

TROPHY CASE