Looks good, something that caught my eye. Using unchangeable for describing tuple, it is called immutable More on reddit.com

Good for people getting into programming in general. I only have one remark: I wouldn't qualify O(n) as "Slow !" since it's still practically fast for low values of n and has the elegance of scaling linearly, which is one of the best scenarios available in the vast amount of cases a programmer will face. More on reddit.com

Damn. You know how Volvo made the seat belt and gave out the design for free for all car manufacturers to make safer cars and them not making any money off of it. You are like a python volvo. More on reddit.com

There's not really a fixed list of things you can memorize to suddenly do better on leetcode (or even moreso actual programming applications). Instead, you have to develop a workflow and put in the time to develop creative solutions. Workflow-wise, what I usually do for these kinds of interview or practice questions is start with the simplest thing that might possibly work. So in Two Sum you might first think about going through the array and doing all pairs or whatever. Obviously, the immediate, simple solution is probably not optimal, so you need to know enough about algorithms and Big O to figure out what kind of runtime you're looking at - in this example, all pairs is usually N2. So the next thing you do is try to refine that solution - what's lower order than N2? Well, lots of things, search on sorted arrays is log N, and sorting them first is N log N, running a constant number of times through an array is N, hashing is constant, etc. So using these building blocks, you try something else - maybe now you can figure out a way to read through the array several times and store something for later, so you're trading memory for time. And then you try to figure out if you can trim your improved solution down. How do we look things up fast? A hash table would probably do that so we implement that, and so on and so forth... And basically, that's it. You start with something you know works, you figure out what it costs, look at other options based on your knowledge of data structures and algorithms, iterate through some new techniques, try some common tradeoffs like space for speed, and then polish the answer. I think this is a useful approach because you can also apply it to real problems, since you can always ask similar questions in a real workflow about what the goal is, what resources you have, etc. Also, for leetcode in particular, it's usually better to focus on sufficiently different broad categories (array/list vs. tree vs. hash table) rather than fairly similar solutions that might only get you a little improvement (AVL vs. Red-Black trees, etc). And if you're specifically interested in coding challenges, it's worth tracking and learning more about the kinds of data structures that crop up often in solutions and their simple variations - binary trees and then interval trees, for example. On the other hand, obscure data structures with theoretically better performance probably aren't going to show up because they're not commonly implemented in language libraries and no one can remember how to create them correctly off the top of their heads - that's why van Emde Boas trees don't crop up a lot in these things. More on reddit.com