You're struggling to understand algorithms. What's the best way to learn about them?

No Distractions Have a gadget free date with your algorithms and coding. Repeat until you are in committed relationship with your no distraction learning time daily.

When it comes to picking up such applied skills, true understanding may not necessarily involve a deep philosophical or intuitive grasp of concepts. Instead, one should aim to attain a level of proficiency and comfort by repetitively putting the underlying principles to use through practice, by coding their own algorithms. While deep comprehension is valuable, it might not always be a prerequisite for effectively using algorithms to solve problems or derive solutions. I find this emphasis on acclimatization over comprehensive understanding to be useful when working on an unfamiliar topic. The initial focus should be on immersion, gradual familiarization, and persistent practice rather than immediate and comprehensive understanding.

It is paramount to acquire a solid foundation in the fundamentals, as it serves as a crucial tool for the design and implementation of algorithms.

What I do is I read the algorithm and then try to dry-run it without any help. Make diagrams of how states are getting changed. For example, in case of Fenwick tree, I write the range of elements which a particular tree node will contain and construct a tree as well to imagine, to understand how to run the read and update operation on the tree. And I keep doing that until I have a clear picture, also solve a couple of basic questions while I am at it.

Often finding a starting point and a rigorous path ahead to learn them systematically is bit difficult as people are presented with multiple choices. The first thing is to acquire acquaintance with a programing language and then use the same to solve easy questions. Easy questions means the one requiring to ponder upon a specific concept. Solving questions and reviewing theoretical concept should go hand in hand.

If you're finding algorithms challenging, the best way to improve is by practicing coding.you've got to get hands-on with the code. By coding algorithms yourself, you reinforce your understanding, test your knowledge, and build your intuition. You can use any programming language you're comfortable with like C++, Java, Javascript ,etc. Look for online platforms like LeetCode, HackerRank, CodeChef that offer algorithm problems and challenges. Start with easier problems and gradually work your way up to more difficult ones. Practice makes perfect, so don't hesitate to dive in and start coding!

Merely grasping the fundamentals is insufficient for acquiring and enhancing skills in algorithm design. Consistent practice is imperative. While leveraging online platforms is beneficial, I also recommend hands-on implementation for a more comprehensive learning experience.

Ah, the journey of understanding algorithms is one of both challenge and reward. In my experience, the best approach is to start with a solid foundation in the fundamentals of computer science, mastering concepts like data structures and basic algorithms. From there, immerse yourself in practice – solve problems, dissect existing algorithms, and analyze their efficiency. Embrace the wisdom of others, seek guidance from mentors, and don't shy away from failure, for it is often the greatest teacher. Remember, true understanding comes not just from knowing how algorithms work, but also from grasping the principles behind them and their applications in various domains.

Learning the algorithms wouldn’t last very long in your memory, it’s the practice of questions which are solved using these algorithms which helps you remember these algorithms for a very long time.

Some areas of analysis in reviewing your own solutions (and comparing your solutions to those of your peers) that were not covered include: Proofs: Prove the correctness of your algorithm using such techniques as mathematical induction. Time and Space Complexity: Analyze the time and space complexity of your solution. Ensure it meets the problem requirements. Consider worst-case scenarios (time/space) and solution optimality. Algorithmic Techniques: Understand the algorithmic techniques used in your solution (e.g., dynamic programming, greedy algorithms, etc.). Review their correctness and efficiency.

Unless you do rocket science, you'll probably won't put much effort in reviewing a code who has been validated or pushed in production. In a business scope, you want fast iterations on different subjects. But when you are creating a data handling solution, you'll probably have to use information from the www in conjonction with you own knowledge.

Reviewing solutions of others after solving a particular problem is of vital importance. First thing is after solving problem, person is in right mindset to weight various approaches. Sensing these minute tradeoffs will be instrumental in long run.

Play with the algorithms. Adapt to your requiremens that also might be considering resource usage (speed, memory, power consumption...) or concurrency. In this step you will get more insights on how and why some algorithms are designed the way they are.

Best way to do that according to me is to find a a subject who is part of your day/week and try to have better understanding of it using a homemade algorithm. For example, I love deck building games, so I created an algorithm who gives me hints on what specific card I should use in my deck + what cards synergize we'll together.

Follow the rule - the simplier the better. Before starting code optimization by developing a sophisticated algorithm, make sure it's really needed. A sophisticated algorithm often means a complicated code which, in its turn, yields loss of transparency, extra debugging and maintenance efforts. If your code faces too low performance, first try to localize a bottle neck - a code fragment that consumes main CPU or memory resourses, and try to optimize it.

There is no end to the algorithms and their variants with more in pipelines. Going through the publications in particular field, one is interested in, is of great help. Going through the engineering blogs of various companies is another rich source.

When exploring different algorithms, start with simple proof-of-concepts and adapt them. Measure performance, if this is an requirement, and adapt or even take a more complex solution.

These steps don't need to be followed in a rigid sequence. For example, once you learn about stacks, implement a stack in your favorite programming language. Then do that for queues. Then write a stack using queues and queues using stacks. This makes the learning process more iterative and concrete. This way, when you get to something more complex like tree traversal, the basic data structure algorithms are already in your toolbox.