O que você faz se estiver lutando com design de algoritmos na ciência da computação?

Algorithm design is complex process, you have do it to understand it. You cant read about algorithms and think that you understood it. The fine grain detail are only understood once you practice it. It needs a lot of practice and implementation to get hold of it. Start with simple algorithms and try building up on them as you go to complex ones.

If algorithm design poses a challenge, start by mastering fundamental data structures and algorithms, then practice extensively on platforms like LeetCode or HackerRank. Break down complex problems into manageable parts and analyze both time and space complexity. Learn diverse algorithmic techniques such as divide and conquer, dynamic programming, and greedy algorithms, adapting them to different problem types. Reflect on and optimize solutions, seeking help from peers, professors, or online communities when stuck. Teaching others reinforces understanding, while studying solutions from skilled practitioners offers valuable insights

From my perspective, the first thing to understand is the problem itself, and then evaluate whether it fits the algorithm you are struggling with. Then, you decompose the algorithm into smaller parts to check for bias or other variables detected as problematic during your decomposition. Sometimes, the struggle has a conceptual issue other than the mathematical method.

Read. Read. Read. It's always important for any Software Engineer, or any kind of career in the tech industry to take a step back and spend a few moments to refresh your knowledge of the basics, and sometimes, might end up learning a few new tricks. One mistake I had during my university days is not embracing programming principles, which then became my motivation to keep learning.

If you get stuck the most repeating or frequent advice I got is search online, ask people, learn online. There is always something new to learn and one should always have a hand over basic concepts.

When confronted with a complex algorithm, decomposing the problem into smaller, more manageable pieces is a valuable strategy. This method allows us to focus on one aspect of the problem at a time, making it less intimidating and easier to tackle. First, I would begin by writing down what I know about the problem and what I need to find out. This helps in clarifying the problem statement and understanding its requirements. Then, I would decompose the problem into smaller sub-problems, each of which I can solve independently. This approach not only helps in solving the immediate problem but also in identifying reusable patterns and strategies that can be applied to other algorithmic challenges.

Breaking down complex algorithms into smaller, more manageable pieces is key. This method, known as decomposition, allows you to focus on one aspect of the problem at a time. Write down what you know and what you need to find out. By simplifying the components, you can often see a clearer path to a solution. This approach not only makes the problem less intimidating but also helps in identifying reusable patterns that can be applied to other algorithmic challenges.

When tackling a complex algorithm, employing the technique of decomposition can be immensely beneficial. Breaking down the problem into smaller, more manageable pieces enables you to concentrate on individual aspects incrementally. Begin by delineating what you already know and what information you need to discover. By simplifying the components, a clearer path to a solution often emerges. Not only does this method alleviate the intimidation factor of the problem, but it also facilitates the identification of reusable patterns that can be applied to address other algorithmic challenges effectively.

Divide and conquer is my motto. I try to break down the problem into smaller problems that are easier to understand solve. Once I managed to break down the problem I start working on the solution. Also, if there is an issue later in one of the parts, it’s much easier to fix than to start looking for an issue in a big complex algorithm.

1. Guess the intuition behind each step. If two/more steps serve a single intuition, group them together as a block. 2. Now draw a visual representation of them. On a fresh paper, draw one rectangle representing each block, downwards one after another. 3. Write on each rectangle the 'intuition' that the group serves (forget about steps, we're interested in abstract understanding). 4. Connect them by arrow and turn into a flowchart. 5. Observe each rectangle, what input it takes, what output it gives. 6. Finally consider the flowchart in big picture. 7. Having understand it in abstract level, now we take each rectangle at a time, dive into details, the steps that are grouped in it. We research the mechanism of the individual steps.

Seeking feedback from peers, mentors, or online communities is invaluable. Explaining your algorithm to someone else can clarify your thinking and highlight areas that need improvement. Peer review is a valuable tool in computer science; it can provide new perspectives and insights that you might have missed. Additionally, discussing your struggles openly with others who have faced similar challenges can be both reassuring and enlightening.

Seeking feedback from peers, mentors, or online communities is a crucial step in algorithm development. Explaining your algorithm to someone else can clarify your thinking and shed light on areas that may require improvement. Peer review is highly beneficial in computer science, as it offers fresh perspectives and insights that you may have overlooked. Engaging in open discussions about your challenges with individuals who have encountered similar obstacles can be both comforting and enlightening, fostering a collaborative environment where knowledge sharing thrives.

Feel free to reach out to peers, mentors, or online communities for feedback without hesitation. Describing your algorithm to someone else can help clarify your thoughts and pinpoint areas for enhancement. Peer review holds significant value in computer science, offering fresh perspectives and insights you might overlook. Moreover, openly discussing your challenges with others who have encountered similar obstacles can be both reassuring and enlightening.

Like in any kind of work environment, it is always better to have another set of eyes to review your work. Getting unbiased feedback is also a way for us to improve further. In some cases, in a software development team, the DOD or "Definition of Done" of a ticket or a task is based on the number of approval of code reviews from other colleagues.

Practice solving a wide range of DSA problems on platforms like LeetCode, HackerRank, Codeforces, and GeeksforGeeks. Start with easy problems and gradually move to medium and hard ones.

Regular practice and repetition are often underrated. We - engineers - are constantly developing, and we can only do so by regularly doing things. If we do not practice, we forget and eventually get out of date. Even though it’s unlikely we’ll use 95% of the things we learn in our day-to-day jobs, we are getting used to solving problems, and we also have that 5% we will use!

Regular practice is essential for honing your algorithm design skills. By consistently tackling a diverse range of problems from various domains, you can enhance your problem-solving versatility and depth. Online platforms provide a plethora of exercises spanning different difficulty levels, allowing you to continuously challenge yourself. Through regular practice, you'll develop a stronger intuition for algorithm design and become more adept at navigating the trial-and-error process inherent in finding solutions.

Regular practice is essential for mastering algorithm design. Engage with diverse problem sets across various domains to cultivate versatility and depth in your problem-solving abilities. Online platforms provide a plethora of exercises spanning different difficulty levels. By consistently pushing yourself with fresh challenges, you'll hone your intuition for algorithm design and grow more adept at navigating the trial-and-error process inherent in finding solutions.

Like any kind of career, practice always makes perfect. In Algorithm design, it's good that we know the basics, the design patterns, and we have the idea, but practicing in real life problems allows us to come up with realistic solutions. There are a few interesting platforms or resources that could help us become better in algorithms.

From what I've seen, engineers try to jump into writing code without having the solution ready. Writing code is the last step when solving algorithm problems. Before we write code, we should: - understand the problem - come up with a solution - (optional, yet useful) write pseudo code or steps to follow - write code Writing code is only a small fraction of solving a problem.

Before diving into coding the actual algorithm, consider writing pseudocode as a preparatory step. Pseudocode serves as a simplified representation of your code, outlining the logic of the algorithm without the syntax constraints of a specific programming language. This approach allows you to concentrate on the algorithm's structure and flow of logic. Once you've refined the pseudocode to your satisfaction, translating it into real code becomes significantly more straightforward, as you've already tackled the logic hurdles.

IMHO writing a pseudocode can help us to understand what was wrong and what we are missing so that we can search for same basic bases, break the pseudocode piece by piece in order to isolate what is yet to improve, write a more complete ask for help etc.

Utilizing pseudocode can greatly aid in algorithm development by providing a simplified outline of the logic before diving into actual coding. Pseudocode strips away the syntactical constraints of a programming language, allowing you to focus solely on the algorithm's structure and logic flow. By sketching out the algorithm in pseudocode first, you can effectively work through potential logic problems and refine the overall approach. This preliminary step streamlines the translation process when converting the pseudocode into executable code, resulting in more efficient and effective algorithm implementation.

In my experience, writing pseudo code helps me pinpoint issues in my algorithm. After I have an idea of my algorithm, I write it in pseudo code and analyze it first. After a few iterations of analysis and corrections, I begin implementing the code.

I often prefer writing the tests before the code to avoid bias. Write as many as possible before implementing the code. Keeps you in check.

Implemented Algo Samples in depth analysis from performance point of view, may enable us to design and develop optimal algorithm.

It is all the time good to start simple, define your input and the expected output. Then write in your language how you will map the input to the output. Then select your proffered programming language to map that plan into an application or test application. Then run it, make sure that the ouptut is correct then start adding the special cases one by one. once you feel the program is good then go for optimizing the time complexity.

Please don’t rush into writing code; make sure you understand the problem and solve it in your head before you touch your IDE. Make sure you also think about: - edge cases - tests - optimisation You should only start coding if you solved it in your head and considered those mentioned above.

It can help to collaboration with peers who are also studying algorithm design or are AI-tech adjacent. Surrounding yourself with people who can share your experiences with you can positively impact your creativity. Also, being able to explain your thought process and hearing others' perspectives can enhance your understanding and lead to new insights. Keep up with the latest developments and advancements in algorithm design. Follow industry blogs, research papers, and online tutorials to stay informed about new algorithms and techniques. I think it’s important to remember that algorithmic design is an experimental process and thats probably you were initially drawn to the field.

Writing an algorithm might seem like an impossible task. But if I can do it, anyone can. Try to break it down into smaller pieces, take it step by step and don’t be scared if you don’t understand all the concepts. This is where you grow, in the areas you are not so familiar with. In these areas you have an opportunity to learn. Lastly and most importantly, have fun!

In depth analysis of the online algorithm repositories is equal to crowdsourcing or outsourcing your problem. Many repositories have improved implementation platforms.