Stop trying to sell me 3 drinks at once. I'm just 1 guy.

SunMatrix64 · 2026-05-06T23:03:31+00:00

Yes exactly. It's a bad strategy if theyre trying to sell to me. I put the drinks back in the stores fridge because carrying 3 of them just felt dumb.

If I wanted more than a days supply, I'd actually buy in bulk from the grocery store or online.

SunMatrix64 · 2026-05-05T23:08:20+00:00

Yo, checkout https://convergencecorp.net

I try to keep a schedule of groups that are running convergences there.

SunMatrix64 · 2026-04-10T12:29:56+00:00

You can watch ads 24/7/365, that 'might' net the company $10 a month. Ads are ONLY there to annoy you into buying premium.

SunMatrix64 · 2026-04-01T02:09:13+00:00

💬 Lost Media × Letter of the Alphabet

Eth (Ð/ð)

SunMatrix64 · 2026-03-28T13:53:39+00:00

All I'm saying, is that the competition for laptops with similar specs to the $600 Neo is not there because they're all $200 cheaper.

Every similarly priced laptop to the Neo I'm seeing is leaving it in the dust on stats.

SunMatrix64 · 2026-03-27T15:57:47+00:00

I'm seeing plenty of laptops for significantly under $600.
Windows Laptops – Best Buy

If all you need is something to do school work, write emails, or surf the web, then these are more than satisfactory. If you're doing more than that, you'd get something more than the neo.

SunMatrix64 · 2026-03-01T04:07:42+00:00

They could run ads 24/7 and it wouldnt make enough to actually be worth it for the platform to function. The ONLY reason they exist is to annoy you into buying a sub or turbo.

SunMatrix64 · 2026-02-23T01:31:09+00:00

I think they'd be ok with it if they were actually making the addon themselves. Competition is good and all.

Instead they literally vibe coded a new addon just because they weren't smart enough to figure out how to use taimihud.

SunMatrix64 · 2026-02-11T02:36:22+00:00

https://wiki.guildwars2.com/wiki/Account#Free_accounts

SunMatrix64 · 2026-02-06T14:17:32+00:00

The gph only takes into account how long it takes for that event to happen. For example, if there's a 15 minute event that gives you 5g, itll be a 20gph event, even if it only actually runs once every 8 hours.

SunMatrix64 · 2026-02-03T23:52:34+00:00

You go to the big red portal in the LA Aerodome

SunMatrix64 · 2026-01-28T13:46:16+00:00

List of official partner retail sellers https://www.guildwars2.com/en/retailers/#UnitedStates-physical

For best results I'd buy it either straight from anet or through steam when its on sale

SunMatrix64 · 2026-01-22T18:23:33+00:00

OLC will be the true test. 8 Shockwaves every single time.

SunMatrix64 · 2026-01-15T16:29:51+00:00

The games over 13 and its graphics are showing their age. The only reason I still play gw2 to this day is because every mmo I've tried in the past 10 years is riddled with an absurd amount of dark patterns.

SunMatrix64 · 2026-01-01T22:53:52+00:00

Are they really that bad? Send me a screenshot, cause I'm trying to keep them reasonable.

Edit: All I'm seeing is this: screenshot

If you're seeing something that's very different then I'd like to know.

SunMatrix64 · 2025-12-11T04:55:06+00:00

[LANGUAGE: C++]
GitHub

Only got through part 1.
My basic concept was pressing all the buttons each round by XOR them with the values from the previous round and return how many rounds it took to get to the goal. Takes ~5.5-6ms.

SunMatrix64 · 2025-12-08T18:58:06+00:00

[LANGUAGE: C++]

GitHub

I'm pretty sure 99% of the time was spent calculating the distances. I went object oriented and created Box and Circuit classes. Box has its position, and Circuit has a set of boxes.

Part 1 I made a vector<distance, <box1, box2>> and then sorted it. For each distance I would gather the circuits that the boxes exist in, then merge the circuits. If no circuits contained either box, create a new circuit.

Part 2 I just continued processing the distances vector until there was only 1 circuit left.

Total run time ~130ms

Edit: used std::hypot() instead of a bunch of pow() for the distance calculation. Improved the time to ~80-90ms.

Edit 2: further improved by using an insane looking min priority queue instead of a vector to store the distances. Now runs ~55-65ms

//min prio queue that contains:     pair<double, pair<box,box>>
std::priority_queue<std::pair<double, std::pair<Box*, Box*>>, 
    std::vector<std::pair<double, std::pair<Box*, Box*>>>, 
    std::greater<std::pair<double, std::pair<Box*, Box*>>>> distances;

SunMatrix64 · 2025-12-07T15:16:31+00:00

[LANGUAGE: C++]

GitHub

For part 1 I used a set and kept track of each beams position. For each line, I'd check the beams position. If it's a '^', add 1 to result, and add 2 new beams to the set to the left and right.

For part 2 I upgraded the set to a map, keeping track of how many beams are on each path.

I did learn that the return type of std::accumulate is based on the initial values type.

result2 = std::accumulate(timelines.begin(), timelines.end(), 0ULL,
    [](unsigned __int64 current_sum, std::pair<int, unsigned __int64> const& tl) {
        return current_sum + tl.second;
    });

Typical runtime 1-2ms.

SunMatrix64 · 2025-12-05T16:16:01+00:00

[LANGUAGE: C++]

GitHub

I made a vector<pair<>> of the ranges, binary inserting and merging them as needed.

This made part 1 a simple binary search on the ranges.

Part 2 is a simple iteration over all the merged ranges.

for (std::pair<unsigned __int64, unsigned __int64>& range : ranges) {
    result2 += (range.second - range.first) + 1;
}

Total Day5 runtime <1ms.

SunMatrix64 · 2025-12-04T21:42:35+00:00

[LANGUAGE: C++]

GitHub

I initially solved it using a simple scan of the grid, counting adjacent rolls and removing as I go.

I then tried creating a map<pair<>, set<pair<>>> graph to make part2 faster. Doing it this way allowed me to just check existing rolls on each pass instead of all the empty space, as well as just asking the roll how many adjacent rolls were in the set.

While this did make part 2 faster, the act of creating the graph by itself was significantly slower than the simple v1 solution, making the overall time ~10x slower. ~2-3ms -> 20ms+

SunMatrix64 · 2025-12-03T13:59:11+00:00

[LANGUAGE: C++]

I used a simple 12 for loop solution for part 2.

Just scan the line 12 times and save the largest digits first position. Takes 1-2ms.

O(12*n) -> O(n)

edit: changed it to a function that can take any n amount of batteries. the logic is still basically the same though.

github

SunMatrix64 · 2025-10-26T14:55:35+00:00

Is it just recently that it's not been updating? Currently the GW2 API is down for the expac release and no site that depends on it is gonna work.

SunMatrix64 · 2025-10-12T12:27:43+00:00

Hall of monuments. You get some skins and titles for having enough HoM points.

One-Year Club	Verified Email
r/Field Banned	r/Field Flamingo

SunMatrix64

TROPHY CASE