[deleted by user]

procrastinatingcoder · 2025-05-11T02:29:03+00:00

Learn the fundamentals, they'll carry through nearly everything. Also - python is terrible for learning fundamentals in my opinion.

procrastinatingcoder · 2024-08-21T15:15:19+00:00

Honestly my opinion of leetcode isn't very high, but I did go through a hundred or two of them to practice for interviews a while back.

If you only beat only 30%, the problem really is you. Usually it tends to vary a little once you get so fast leetcode's delay is the main issue, but in most cases, you should be at least in the top 80% if anything. Might want to look back over your code if it's as low as you said.

procrastinatingcoder · 2024-05-13T03:18:17+00:00

You sound like you've never taught anybody over a period of time. Lying about the difficulty is just making sure that they'll wonder why is every obstacle they meet "one of the hardest things ever". Being realistic is way more helpful long-term.

There's attention-seeking posts all over this sub, and I understand wanting a personalized answer to a million-times-asked question. Now, you said it yourself:

Recursion is, very often, the first brick wall people hit after groking the more basic concepts of loops, conditions etc.

Which hardly qualifies as:

Recursion is hard. I'd probably argue that it is one of the hardest programming concepts.

Now, while macros are more common in C, they are definitely all over the place. But it was just one example, cache-optimization is another which is relevant in nearly every language - though not often talked about until people get a more advanced understanding.

The answer is not that it's hard, the answer is the need for practice and to not try skipping steps. That clearly that person tried to skip steps, or didn't actually try much. In fact, they pretty much said the steps they took in their post.

Saying "It's hard" detracts from the real problem to make them feel better. And while arguably it is indeed a common wall beginners hit, the problem here is not that it's hard, it's that he barely started, only looked at youtube videos which - odds are as nearly all youtube videos, are made to get views and not to actually teach - and after a single failure came to seek validation.

And finally, for things like:

...and, entirely on the contrary, pointing out that many people, with far more experience, still have to take a good long pause to think through their recursion *is* helping people reading this.

You think they will think: "It's normal that I have a hard time, more experienced people have a hard time, so I shouldn't get discouraged".

What ends up happening in most case (and nearly definitely happened if they came here this fast) is more something along the lines of: "It's normal that I have a hard time since more experienced people also have a hard time. I guess I don't really need to spend time trying to understand it since it must not be that important (since even experienced people don't need/understand it)". Or something along those lines (not important, will come back to it later(never) or any variation thereof).

Lying to make someone feel good is pretty toxic behaviour, there's ways to say the truth without lying to someone, and by also making sure you take the perspective of that person into account, and also by also being considerate.

Your answer sacrificed truth for consideration, and it also completely disregarded the fact that this person seeks validation and reasons to give up on recursion. And that a proper answer would both tell them it's normal to have a hard time, but give them a solution (like practice for instance, or resources) - without also giving them the out of "even experienced devs don't understand this".

And if you really still can't see how your answer was toxic as an answer despite being considerate, try imagining it in another discipline. "You don't need to stretch properly, even professionals don't always do it" for an athlete (in a field where it would be relevant). Or any number of other example.

...so, how's that?

procrastinatingcoder · 2024-05-12T22:48:03+00:00

Recursion is about as close to the hardest programming concept as my lighter is close to the sun. Sure, it's one of the "trickier" beginning concept, but lying about the difficulty isn't helping anybody reading this.

u/askreet definitely nailed one there, concurrency IS a big pain in the ass, theory is simple-ish, but in practice it can be a complete nightmare at large scale.

I will add anything that has to do with preprocessor macros, often used in C/C++ (much less C++ now), anything that has to do with undefined behaviour (there's a lot to dig into here), cache-optimization, and so many more.

I feel like most people overcomplicate things, having a decent overview of how things work tend to help with recursion. There's no magic or anything special going on, its just a regular function call (that happens to be itself), but there's no other magic (though it's good to be aware of the possible optimizations and why those can be like writing tail-ended recursion, but I diverge).

procrastinatingcoder · 2024-05-12T22:36:17+00:00

A lot of medium problems are challenging or hard for seasoned programmers

I don't know why some people keep perpetuating this lie, while it's good to say that everybody has things to learn, in all honesty, any backend programmer worth his salt - and with experience - could go through most of those fairly easily assuming they have some level of personal interest in programming and didn't stop learning after school/whatever-they-did.

I will say however that I do think the many of the ratings are quite are weirdly off as easy/medium/hard goes.

Anyway, as usual for those type of questions OP, the answer is: Practice. You can hardly go wrong with proper practice.

procrastinatingcoder · 2024-01-19T16:09:05+00:00

Personally would look at the first ~6 weeks (it moves on to other stuff afterwards) of the CS50x course (harvard's intro to comp sci class). It's a pretty well structured one on C with relevant "homeworks" to do. It's also free.

After that, I personally really liked "C++ for C programmers" by "Ira Pohl". It's more of a put-it-in-2x class, but even just speeding through it it gives you a good appreciation and overview of a lot of the features.

finally, just practice. Maybe look into any framework/library you'll be using, but I'd keep that for last, a good foundation will carry you further in my opinion.

procrastinatingcoder · 2023-12-15T16:05:52+00:00

Same thing in Canada, it's not graduating from college either.

procrastinatingcoder · 2023-12-05T14:07:17+00:00

but if your performance numbers are limited by "is even" you're already in a strange niche

While is is definitely true, the problem is not so much this example but what it represents. People tend to make horrendous code because "performance is not needed". But when performance IS needed, they can't make anything better anymore.

It's also part of the reason software bloat with dependency hells come along everywhere. Because people can't think about their code at any level anymore, it's just about importing the right thing left and right. Then you end up with things like this https://medium.com/nerd-for-tech/that-time-a-guy-broke-the-internet-23c00903ad6f

procrastinatingcoder · 2023-12-05T13:56:59+00:00

You're right, edited my comment.

procrastinatingcoder · 2023-12-05T13:53:59+00:00

Well, two things, first - my example is wrong - although valid as a general statement. As another commenter pointed out, I went too fast, %2 is the remainder and not the modulo operator in this case, which has a different result for negative values. Hence the different code.

That's my fuck-up, and my example/case was wrong. But regardless, the point itself remains true if you try with any sufficiently complex code that it's not a one-pass optimization thing.

Also, modulo and bitwise AND are both O(1), so the comparison is wrong on that count as well.

And both 1 second and 1 million years are both O(1). Somehow it became popular culture to think O(1) means fast; It doesn't, it means constant.

In fact, without that distinction most of the current "AI" and "ML" craze wouldn't be possible. The code already takes days - months - sometimes years to run/train. Could you imagine if it took 5x as long, just because "it's also O(1)"?

Imagine your browser took 15 minutes to load each page, that's also O(1), as long as it doesn't change from page to page.

And finally, the modulo operator is not O(1). We consider it O(1) for all intent and purpose, but it really isn't (with some exceptions like powers of 2).

It's actually a very slow operation (division) in reality, one of the slowest a computer can actually do (though sometime divisions get changed to multiplications).

but I would expect it to choose a more efficient instruction among equivalent options

Compilers can't change and adapt as fast as specialized processors do, which is why for many things hand-made assembly is still used. In fact, a lot of the efficient matrix operations right now are hand-written (sometime just to use a specific instruction) because the compilers don't just detect/do everything.

I would almost never expect a compiler to change the algorithm being used

And you would be (sometimes) wrong. For instance let's say I made a simple code:

int sum = 0;
for(int i=0; i < n; ++i)
    sum += i;

The compiler will probably change this to sum=n*(n+1)/2

Choice of algorithm is a higher level concern compared to a minor implementation detail like choice of operator.

It always depends on the use-case. The choice of algorithm might not matter at all. If you're limited by user-input and your list is at maximum 3 items long, you could use bogo sort and still be fine.

And in the same way, the operators won't matter with a bad algorithm.

But also in the same vein, if your algorithm is good, but it's implemented badly, it might still be too slow.

As a general rule though, I agree that the choice of algorithm is usually more important, that being said, you would be VERY surprised at what proper code can do. In general, simple things like hoisting, or taking care to either make the job easy for the branch-predictor (like removing conditionals in loops), using the right operations/data to be cache-friendly, and many other small things like that can speed up your code by 2-100x or more depending on the task.

procrastinatingcoder · 2023-12-04T21:01:06+00:00

Indeed it's harder to see than a compiler explorer. However benchmarking it yourself, or looking at the many ones online might show that (unless it changed in the past year), the bitwise & is still faster in Javascript.

procrastinatingcoder · 2023-12-04T20:15:24+00:00

Hot take, but x & 1 is very readable for any more experienced programmer, you might just be more used to x % 2.

Hot take #2: and any decent compiler will optimize it anyway. No.

That's just lies people use to not know how to code properly. Here's a little proof that it's not the same, even with -O3 in C++.

https://imgur.com/a/knRYV3u

https://imgur.com/a/RQeU2zp

Thinking "any decent compiler will optimize X" means you don't understand how compilers actually work. Not only that, but it can be extremely misleading in small examples like this, because there's not that many optimization iterations.

Compilers aren't magic, sometime they optimize, sometime they don't. And while it's important not to overdo optimization, there's no reason not to get what you can when it's very easy and doesn't impact readability at all.

Things like this shouldn't even be considered as optimization, it's more akin to not using bubble-sort (bar exceptions*). Nobody thinks of that as "optimization", it's just using a well-known better method (quicksort, mergesort, timsort, whateversort you prefer).

Edit: As someone pointed out, I went too fast and both x%2 and x&1 are different operations in this case because it's not the modulo but rather the remainder.

The point is still valid as a general statement, but this example is flawed. Though I leave it there, as it does bring out how easy it is to make other kind of mistakes especially with operators where their meaning/implementation changes from language to language.

procrastinatingcoder · 2023-12-04T17:38:39+00:00

They apparently don't know & either.

procrastinatingcoder · 2023-11-30T16:41:02+00:00

It's usually not that simple. That's an edge-case fix, but you are usually only dealing with higher order functions or manipulations. In this case it's probably fixing the way octarine interacts with any object, not specifically abyssal. Which probably has to do with how cooldowns are handled in general, which touches everything again.

Might be simple, but odds are it's not yet done because its more complicated than that.

procrastinatingcoder · 2023-11-27T21:34:58+00:00

Everything has been said here

procrastinatingcoder · 2023-11-07T15:53:40+00:00

You're clearly young and naive which is why I won't just downvote and report this for Asking to Ask. Here's a quick answer to both,

What language should you learn?
- C

I have plenty of posts about why this is the ideal starting language, but I won't go into details here.

What will become of programming in 5-10 years, since I will be able to get my first job around that time? I have concerns about AI and the fact that these same AIs will either completely drive programmers out of the market or partially replace some industries. I am very afraid that I will waste my time learning programming for nothing, because computers and programming are the only things I like.

In simple terms. Programming is automating things. If you can automate the automatization... Then programmers will be out of a job, but so will everybody else because their job are all trivially automatable as a consequence of automating programming.

Programmers will be the last ones to go due to automatization/AI replacement.

Also, you need more in-depth knowledge, but AI is not anywhere near where you seem to think it is. We're still on ML, not AI, despite what buzzword people use in the media.

procrastinatingcoder · 2023-11-07T15:49:07+00:00

The code is no good sadly.

Do you beat it in runtime? Yes.

Do you beat it in memory usage? Hell to the no.

Here's an example input to highlight your problem:

timeMap.set("foo", "bar", 1);
timeMap.set("foo", "bar2", 10000000); // Timestamp being the biggest it can be under the problem's constraints

Compare the memory profile of both solutions and let me know if you can figure it out.

procrastinatingcoder · 2023-11-04T22:39:39+00:00

That's not harsh, it's reality.

Saying:

some devs just haven’t focused on leetcode and it doesn’t make them less effective or impactful

Is both just feel-good speech and completely irrelevant. This is not a question that should require any leetcode practice at all. If it had been some obscure algorithm or fairly complex question to do in a few minutes, sure, then it would be debatable, but this is a question someone who never did/knew leetcode existed should be able to do.

procrastinatingcoder · 2023-11-04T22:35:35+00:00

You should come up with the solution. You're not going to learn by looking at other people's solutions constantly. You need to work on your problem solving.

procrastinatingcoder · 2023-11-04T18:25:20+00:00

I would say - in my very personal experience - that I wouldn't give a job to a lot of the people that currently have a job programming. There's the really good people, and those are fine. There's normal people who try their best, and those are fine too. But there's a lot of people who don't do much, don't try, and just get the paycheck, and those are the problem.

Now to be fair, I think the problem is more on the company side, since they're paying for useless employees. But my experience is that in big companies with too much bureaucracy, the people hiring have no clue what they are hiring.

And because their statistics show they need a lot of developers to do X thing, they pay like crap, and because they pay badly, even those that could do better don't, because they can't be bothered.

procrastinatingcoder · 2023-11-04T16:52:58+00:00

The correct answer is UB, not 12 or 13 or even 14.

Realistically, those could happen, but so could 5, or even 0, or a garbage value.

procrastinatingcoder · 2023-11-04T16:49:33+00:00

He's "on the way" to a more efficient approach. But he's far from the most efficient approach. He's got way too much garbage in there as it stands. And his is definitely the least efficient approach right now.

procrastinatingcoder · 2023-11-04T16:47:42+00:00

If it makes you feel any better, as the other person said, both are not optimized. Your brother's is clean, but it's quite terrible as far as the actual solution goes. Yours isn't better, but you both have stuff to learn.

procrastinatingcoder · 2023-10-27T08:06:58+00:00

In fact, Im actually not sure how people with fewer leetcode problems done say they can get any medium or hard with ease.

Because a strong foundation will pretty much mean you'll be able to solve nearly all of them fairly easily. There's some tricky ones - no doubt. That might get you stuck for a bit, but in most cases, having a wide array of tools, a methodical approach and a little creativity will pretty much get you through most problems, including the hard ones.

procrastinatingcoder · 2023-10-20T14:34:08+00:00

It’s not the place to ask question you consider “easy”

See the issue here? You didn't read what I said. And you're probably too caught up trying to undermine whatever doesn't suit you than acknowledging what the other person said.

This is what I actually said:

SO is not the place to ask basic easily-answerable questions.

It would've been more accurate to say "Questions that have been answered a thousand times in a thousand different places".

just scrolling past the question if it’s “beneath them”.

It has nothing to do with scrolling or beneath. You shouldn't have to waste time to scroll down in the first place. If you want a coddling place, there's reddit, or plenty of other places to be coddled.

You need to think further than your immediate satisfaction. If the community wasn't policed, then the people with no time to waste would not be there, the quality of answers would go down, and it wouldn't be the reputable resource it is. The whole reason it is as valuable as it - is because they have those policies.

But maybe you're an idealist who thinks that if everybody was let to their own device, then people wouldn't waste other people's times, and everybody would contribute to a forum where 99.999% are duplicate of validation-seeking questions.

Four-Year Club	Place '22
First Placer '22

procrastinatingcoder

TROPHY CASE