problem solving coding algorithm

How to Solve Coding Problems with a Simple Four Step Method

I had fifteen minutes left, and I knew I was going to fail.

I had spent two months studying for my first technical interview.

I thought I was prepared, but as the interview came to a close, it hit me: I had no idea how to solve coding problems.

Of all the tutorials I had taken when I was learning to code, not one of them had included an approach to solving coding problems.

I had to find a method for problem-solving—my career as a developer depended on it.

I immediately began researching methods. And I found one. In fact, what I uncovered was an invaluable strategy. It was a time-tested four-step method that was somehow under the radar in the developer ecosystem.

In this article, I’ll go over this four-step problem-solving method that you can use to start confidently solving coding problems.

Solving coding problems is not only part of the developer job interview process—it’s what a developer does all day. After all, writing code is problem-solving.

A method for solving problems

This method is from the book How to Solve It by George Pólya. It originally came out in 1945 and has sold over one million copies.

His problem-solving method has been used and taught by many programmers, from computer science professors (see Udacity’s Intro to CS course taught by professor David Evans) to modern web development teachers like Colt Steele.

Let’s walk through solving a simple coding problem using the four-step problem-solving method. This allows us to see the method in action as we learn it. We'll use JavaScript as our language of choice. Here’s the problem:

Create a function that adds together two numbers and returns that value. There are four steps to the problem-solving method:

• Understand the problem.
• Devise a plan.
• Carry out the plan.

Let’s get started with step one.

Step 1: Understand the problem.

When given a coding problem in an interview, it’s tempting to rush into coding. This is hard to avoid, especially if you have a time limit.

However, try to resist this urge. Make sure you actually understand the problem before you get started with solving it.

Read through the problem. If you’re in an interview, you could read through the problem out loud if that helps you slow down.

As you read through the problem, clarify any part of it you do not understand. If you’re in an interview, you can do this by asking your interviewer questions about the problem description. If you’re on your own, think through and/or Google parts of the question you might not understand.

This first step is vital as we often don’t take the time to fully understand the problem. When you don’t fully understand the problem, you’ll have a much harder time solving it.

To help you better understand the problem, ask yourself:

What are the inputs?

What kinds of inputs will go into this problem? In this example, the inputs are the arguments that our function will take.

Just from reading the problem description so far, we know that the inputs will be numbers. But to be more specific about what the inputs will be, we can ask:

Will the inputs always be just two numbers? What should happen if our function receives as input three numbers?

Here we could ask the interviewer for clarification, or look at the problem description further.

The coding problem might have a note saying, “You should only ever expect two inputs into the function.” If so, you know how to proceed. You can get more specific, as you’ll likely realize that you need to ask more questions on what kinds of inputs you might be receiving.

Will the inputs always be numbers? What should our function do if we receive the inputs “a” and “b”? Clarify whether or not our function will always take in numbers.

Optionally, you could write down possible inputs in a code comment to get a sense of what they’ll look like:

//inputs: 2, 4

What are the outputs?

What will this function return? In this case, the output will be one number that is the result of the two number inputs. Make sure you understand what your outputs will be.

Create some examples.

Once you have a grasp of the problem and know the possible inputs and outputs, you can start working on some concrete examples.

Examples can also be used as sanity checks to test your eventual problem. Most code challenge editors that you’ll work in (whether it’s in an interview or just using a site like Codewars or HackerRank) have examples or test cases already written for you. Even so, writing out your own examples can help you cement your understanding of the problem.

Start with a simple example or two of possible inputs and outputs. Let's return to our addition function.

Let’s call our function “add.”

What’s an example input? Example input might be:

// add(2, 3)

What is the output to this? To write the example output, we can write:

// add(2, 3) ---> 5

This indicates that our function will take in an input of 2 and 3 and return 5 as its output.

Create complex examples.

By walking through more complex examples, you can take the time to look for edge cases you might need to account for.

For example, what should we do if our inputs are strings instead of numbers? What if we have as input two strings, for example, add('a', 'b')?

Your interviewer might possibly tell you to return an error message if there are any inputs that are not numbers. If so, you can add a code comment to handle this case if it helps you remember you need to do this.

Your interviewer might also tell you to assume that your inputs will always be numbers, in which case you don’t need to write any extra code to handle this particular input edge case.

If you don’t have an interviewer and you’re just solving this problem, the problem might say what happens when you enter invalid inputs.

For example, some problems will say, “If there are zero inputs, return undefined.” For cases like this, you can optionally write a comment.

// check if there are no inputs.

// If no inputs, return undefined.

For our purposes, we’ll assume that our inputs will always be numbers. But generally, it’s good to think about edge cases.

Computer science professor Evans says to write what developers call defensive code. Think about what could go wrong and how your code could defend against possible errors.  

Before we move on to step 2, let’s summarize step 1, understand the problem:

-Read through the problem.

-What are the inputs?

-What are the outputs?

Create simple examples, then create more complex ones.

2. Devise a plan for solving the problem.

Next, devise a plan for how you’ll solve the problem. As you devise a plan, write it out in pseudocode.

Pseudocode is a plain language description of the steps in an algorithm. In other words, your pseudocode is your step-by-step plan for how to solve the problem.

Write out the steps you need to take to solve the problem. For a more complicated problem, you’d have more steps. For this problem, you could write:

// Create a sum variable.

Add the first input to the second input using the addition operator .

// Store value of both inputs into sum variable.

// Return as output the sum variable. Now you have your step-by-step plan to solve the problem. For more complex problems, professor Evans notes, “Consider systematically how a human solves the problem.” That is, forget about how your code might solve the problem for a moment, and think about how you would solve it as a human. This can help you see the steps more clearly.

3. Carry out the plan (Solve the problem!)

The next step in the problem-solving strategy is to solve the problem. Using your pseudocode as your guide, write out your actual code.

Professor Evans suggests focusing on a simple, mechanical solution. The easier and simpler your solution is, the more likely you can program it correctly.

Taking our pseudocode, we could now write this:

Professor Evans adds, remember not to prematurely optimize. That is, you might be tempted to start saying, “Wait, I’m doing this and it’s going to be inefficient code!”

First, just get out your simple, mechanical solution.

What if you can’t solve the entire problem? What if there's a part of it you still don't know how to solve?

Colt Steele gives great advice here: If you can’t solve part of the problem, ignore that hard part that’s tripping you up. Instead, focus on everything else that you can start writing.

Temporarily ignore that difficult part of the problem you don’t quite understand and write out the other parts. Once this is done, come back to the harder part.

This allows you to get at least some of the problem finished. And often, you’ll realize how to tackle that harder part of the problem once you come back to it.

Step 4: Look back over what you've done.

Once your solution is working, take the time to reflect on it and figure out how to make improvements. This might be the time you refactor your solution into a more efficient one.

As you look at your work, here are some questions Colt Steele suggests you ask yourself to figure out how you can improve your solution:

• Can you derive the result differently? What other approaches are there that are viable?
• Can you understand it at a glance? Does it make sense?
• Can you use the result or method for some other problem?
• Can you improve the performance of your solution?
• Can you think of other ways to refactor?
• How have other people solved this problem?

One way we might refactor our problem to make our code more concise: removing our variable and using an implicit return:

With step 4, your problem might never feel finished. Even great developers still write code that they later look at and want to change. These are guiding questions that can help you.

If you still have time in an interview, you can go through this step and make your solution better. If you are coding on your own, take the time to go over these steps.

When I’m practicing coding on my own, I almost always look at the solutions out there that are more elegant or effective than what I’ve come up with.

Wrapping Up

In this post, we’ve gone over the four-step problem-solving strategy for solving coding problems.

Let's review them here:

• Step 1: understand the problem.
• Step 2: create a step-by-step plan for how you’ll solve it .
• Step 3: carry out the plan and write the actual code.
• Step 4: look back and possibly refactor your solution if it could be better.

Practicing this problem-solving method has immensely helped me in my technical interviews and in my job as a developer. If you don't feel confident when it comes to solving coding problems, just remember that problem-solving is a skill that anyone can get better at with time and practice.

If you enjoyed this post, join my coding club , where we tackle coding challenges together every Sunday and support each other as we learn new technologies.

If you have feedback or questions on this post, feel free to tweet me @madisonkanna ..

Read more posts .

If you read this far, thank the author to show them you care. Say Thanks

Learn to code for free. freeCodeCamp's open source curriculum has helped more than 40,000 people get jobs as developers. Get started

Solve Me First Easy Problem Solving (Basic) Max Score: 1 Success Rate: 97.77%

Simple array sum easy problem solving (basic) max score: 10 success rate: 94.51%, compare the triplets easy problem solving (basic) max score: 10 success rate: 95.81%, a very big sum easy problem solving (basic) max score: 10 success rate: 98.81%, diagonal difference easy problem solving (basic) max score: 10 success rate: 96.01%, plus minus easy problem solving (basic) max score: 10 success rate: 98.39%, staircase easy problem solving (basic) max score: 10 success rate: 98.37%, mini-max sum easy problem solving (basic) max score: 10 success rate: 94.45%, birthday cake candles easy problem solving (basic) max score: 10 success rate: 97.14%, time conversion easy problem solving (basic) max score: 15 success rate: 92.34%, cookie support is required to access hackerrank.

Seems like cookies are disabled on this browser, please enable them to open this website

How to Solve Coding Problems: Step-by-Step Guide (2024)

May 20, 2024 · 13 min read

Coding challenges are a common obstacle for many programmers, whether they are just starting or have years of experience.

In this complete guide, we will provide expert tips and strategies for effectively solving coding problems.

By following these valuable tips, you can confidently enhance your problem-solving skills and conquer even the most challenging coding tasks.

Let's get started.

Read the Problem Statement Carefully

Identify key constraints

One imperative step in solving coding problems is identifying the key constraints in the problem statement. These constraints define the boundaries within which your solution must operate and can greatly influence your approach.

Note important variables

Carefully note down important variables mentioned in the problem statement as they often hold crucial information for solving the problem efficiently.

Understanding the significance of these variables can guide you toward the right solution approach.

Remember to consider any implicit variables that might affect your solution but are not explicitly mentioned in the problem statement.

Attention to all variables will ensure a more comprehensive understanding of the problem.

Tip:  Here, you can learn about key  programming definitions and terms

Create your next presentation

snappify will help you to create stunning presentations and videos.

This video was created using snappify 🤩

Break Down Complexity

Divide into smaller Tasks

You'll find that breaking down a complex coding problem into smaller tasks makes it more manageable.

Start by identifying the different components of the problem and breaking them down into smaller subproblems. This approach will help you tackle each subproblem individually and eventually solve the larger problem.

Focus on one task

The key to successfully breaking down a complex coding problem is to focus on one task at a time.

Concentrating all your efforts on solving one specific subproblem can help you avoid feeling overwhelmed by the complexity of the overall task.

This focused approach will improve your problem-solving skills and allow you to make steady progress toward the final solution.

When focusing on one task, setting clear goals and objectives for that specific subproblem is vital. It will help you stay on track and prevent distractions derailing your problem-solving process.

By dedicating your full attention and energy to each task, you can efficiently work through the complexities of the coding problem and find an effective solution.

Tip:  The  Feynman learning technique  is the best solution for learning how to break down complex concepts.

Research and Learn

Study similar problems

Research shows that one of the best strategies to solve coding problems easily is to study similar problems.

By analyzing how others have approached and solved comparable issues, you can gain valuable insights and techniques to apply to your challenges.

Learn new concepts

Learning new concepts is imperative for continuous improvement in coding.

By staying updated with the latest technologies, algorithms, and best practices, you can enhance your problem-solving skills and broaden your understanding of different coding techniques.

Any aspiring coder should regularly explore new concepts through online courses, tutorials, and coding challenges.

This proactive approach helps solve current problems more effectively and prepares you for future challenges in the ever-evolving tech industry.

Tip:  The fastest way to learn any new concept is to share what you learn. For example, you can learn a piece of code and then use  code sharing tools  to share your knowledge with the audience.

Write Pseudocode First

Plan out Algorithm Steps

For effective problem-solving, it is crucial to plan out the steps of your algorithm before writing actual code.

Pseudocode helps break down the problem into smaller, manageable steps, making it easier to implement the solution in the chosen programming language.

Visualize solution flow

While writing pseudocode, visualize how the solution will flow from one step to another.

This visualization helps in understanding the logic of the algorithm and can highlight any potential issues or optimizations that can be made before writing actual code.

For instance, if you are working on a sorting algorithm, visualizing the flow can help you determine the most efficient way to arrange the elements and identify any redundant steps that you can eliminate to improve performance.

Start with Simple

Implement basic solution

Unlike complex problems, coding problems are best tackled with a straightforward approach.

Begin by implementing a basic solution that may not be the most efficient but solves the problem correctly.

This helps in understanding the problem better and getting a working solution.

Refine as needed

Implementing a basic solution is just the beginning.

As you progress, refine your code by optimizing it for performance, readability, and scalability.

Refactoring code to improve efficiency and incorporating best practices will boost your solution to the next level.

A key strategy for refining your code is to analyze its complexity and identify areas for optimization. This may involve revisiting your algorithm choices and data structures or breaking down the problem into smaller, manageable parts.

By continuously refining your solution, you improve your coding skills and enhance the quality of your code.

Use Online Resources

Leverage coding communities

Despite the various challenges of coding problems, the process becomes easier when you tap into the wealth of knowledge available in coding communities.

These online platforms, such as Stack Overflow and GitHub, offer a supportive environment where you can seek solutions, ask questions, and learn from experienced programmers.

Consult online tutorials

These resources provide step-by-step guidance on various programming concepts and problem-solving techniques, making grasping complex algorithms and data structures easier.

The abundance of online tutorials ranges from beginner to advanced, and they are fit for programmers of all proficiency levels.

By consulting these tutorials, you can enhance your understanding of coding principles and develop effective strategies for solving various coding problems.

Any aspiring coder should take advantage of the vast array of online resources that can facilitate the process of solving coding problems.

By leveraging coding communities, consulting online tutorials, and exploring other online platforms, you can quickly sharpen your problem-solving skills and become a more proficient programmer.

Tip:  Resources like YouTube and Udemy are great ways. But you can also read the  best development books  to enhance your coding skills further.

Debug Thoroughly

Identify common mistakes

Unlike overlooking small errors, identifying common mistakes is crucial in debugging code efficiently.

Any coder should be aware of recurring issues like:

• Syntax Errors
• Logical mistakes
• Incorrect variable usage

By recognizing these patterns, programmers can initiate debugging and write cleaner code.

Test edge cases

Any comprehensive debugging strategy should include testing edge cases to ensure code reliability and robustness.

By intentionally pushing the boundaries of input values or conditions, developers can uncover potential mistakes that might go unnoticed during regular testing.

This practice helps programmers anticipate and address unexpected scenarios, leading to more resilient code.

Testing edge cases involves evaluating the extremes of input data or conditions to verify the code's behavior under challenging circumstances.

By examining how the program handles unusual or extreme values, developers can identify vulnerabilities or inefficiencies that may occur in real-world usage.

Practice Regularly

Build problem-solving muscle

Your coding skills are like a muscle that needs regular exercise to strengthen. Make a habit of solving coding problems daily to enhance your problem-solving abilities.

Develop coding instincts

Build a strong intuition for coding by practicing regularly.

As you solve more problems, you'll notice patterns and common strategies that can help you tackle new problems more efficiently.

Developing coding instincts involves understanding different approaches to problem-solving and knowing when to apply them. This initiative will guide you in choosing the most effective solutions and optimizing your code for better performance.

Review and Refine

Analyze solution efficiency

Unlike simply finding a solution, it is imperative to analyze its efficiency.

Evaluate the time complexity, space complexity, and overall performance of the code.

This step will help you understand how the code will perform with larger inputs and whether there are any bottlenecks that need to be addressed.

Optimize code quality

Coding problems are not just about finding a solution but also about writing clean and efficient code.

Pay attention to coding standards, readability, and best practices.

Refactor the code to make it more concise, understandable, and maintainable. This step is crucial in ensuring that your code is not only functional but also of high quality.

You can use tools like linters and code formatters to check and improve your code's quality automatically.

These tools can help you catch potential errors, enforce coding standards, and enhance the overall readability of your codebase.

By optimizing your code quality, you can make it easier for yourself and others to understand and work with the code in the future.

Tip:  You can use a  code review checklist  to optimize code efficiency quickly.

Learn from Others

Study open-source code

Study open-source code to truly enhance your coding skills.

By studying the work of experienced developers, you can gain insight into different perspectives, problem-solving techniques, and coding styles.

This exposure can broaden your knowledge and inspire innovative solutions to coding problems.

Learn from mentors

Some of the most effective learning experiences come from mentors who can provide guidance, feedback, and real-world insights.

Connecting with experienced professionals in the field can offer valuable advice, help you navigate challenges, and accelerate your learning process.

Learn from mentors who have expertise in your specific area of interest.

Their guidance can help you grasp complex concepts, avoid common pitfalls, and stay updated on industry trends.

Building a strong mentorship relationship can significantly impact your coding journey and foster professional growth.

Stay Calm and Patient

Manage problem-solving stress

After encountering a challenging coding problem, managing the stress that comes with it is imperative.

Take deep breaths, step back, and remind yourself that feeling stuck is okay.

Keeping a clear mind will help you approach the problem more effectively.

Take breaks when needed

If you find yourself hitting a wall and getting frustrated, it's time to take a break.

Stepping away from the problem for a few minutes or even an hour can improve your mental clarity.

Some fresh air or a quick walk can help reset your mind and improve focus when you return to the task.

When stress builds up, it can blur your thinking and make problem-solving even more challenging.

Taking breaks gives you a chance to relax and allows your brain to subconsciously work on the problem in the background, often leading to new insights and solutions.

Identify Patterns

Recognize common patterns

One vital skill in solving coding problems is recognizing common patterns.

By identifying recurring themes or structures in the problem you're trying to solve, you can apply similar solutions that have worked in the past. It can help simplify your problem-solving process and lead to more efficient coding.

Apply pattern-based solutions

To effectively apply pattern-based solutions, you need to understand different types of patterns commonly found in coding problems.

These patterns can include algorithms like sliding windows, two-pointers, or depth-first search.

By leveraging these patterns, you can quickly develop solutions that have been proven to work for similar problems.

Tip:  You can explore different  development frameworks  to identify common patterns.

Draw Diagrams

Visualize problem structure

When faced with a complex coding problem, start by visualizing its structure.

Use diagrams to represent different components, their relationships, and data flow. This visual representation can clarify the problem and help you identify key areas to focus on.

Illustrate solution flow

While solving coding problems, illustrating the solution flow through diagrams can facilitate the problem-solving process.

Create a step-by-step flowchart or sequence diagram to map the logic and algorithm.

This visual aid can guide you through the implementation phase and help you identify potential errors or optimizations in the solution.

Diagrams can also serve as documentation for your code, making it easier for others to understand your thought process and approach.

By incorporating visual elements into your problem-solving strategies, you can enhance your efficiency and accuracy in coding.

Collaborate with Peers

Work with coding partners

For an effective problem-solving strategy, consider working with coding partners.

Collaborating with peers can help you bounce ideas off each other, share different approaches, and collectively develop innovative solutions.

By leveraging your peers diverse skills and perspectives, you can tackle coding problems more efficiently and effectively.

Learn from peer feedback

Even the most experienced coders can benefit from constructive feedback from their peers.

Peer feedback can provide valuable insights into alternative solutions, code optimization techniques, and potential pitfalls to avoid.

You can continuously improve your problem-solving skills and expand your coding knowledge by actively seeking and incorporating feedback from your coding peers.

Work with your coding partners to brainstorm ideas, discuss different approaches, and troubleshoot any challenges you encounter.

Creating a collaborative environment with your peers can enhance your problem-solving abilities and accelerate your learning process.

Final Words

Mastering the key skills mentioned above will help you solve coding problems more easily and efficiently.

Buffing your problem-solving skills, staying organized, and utilizing various techniques such as pseudocoding and debugging can help you tackle coding challenges with confidence and precision.

Keep practicing and implementing these strategies to enhance your problem-solving abilities and become a more skilled coder.

Why is code optimization important in the problem-solving process?

Code optimization is important in the problem-solving process because it improves the code's performance and efficiency. Optimized code runs faster, requires less memory, and performs better with large input sizes. Optimization reduces the code's time and space complexity and ensures that it meets performance requirements.

Why is testing your code with different test cases important in coding problem-solving?

Testing your code with different test cases helps ensure your solution works correctly for various scenarios. It also helps identify edge cases, errors, and potential bugs in the code. Thorough testing enhances the reliability and accuracy of your code.

Share Article

If you're seeing this message, it means we're having trouble loading external resources on our website.

If you're behind a web filter, please make sure that the domains *.kastatic.org and *.kasandbox.org are unblocked.

To log in and use all the features of Khan Academy, please enable JavaScript in your browser.

AP®︎/College Computer Science Principles

Course: ap®︎/college computer science principles   >   unit 4, the building blocks of algorithms.

• Expressing an algorithm

Want to join the conversation?

• Upvote Button navigates to signup page
• Downvote Button navigates to signup page
• Flag Button navigates to signup page

• Basics of Input/Output
• Time and Space Complexity
• Basics of Implementation
• Basics of Operators
• Basics of Bit Manipulation
• Recursion and Backtracking
• Multi-dimensional
• Basics of Stacks
• Basics of Queues
• Basics of Hash Tables
• Singly Linked List
• Binary/ N-ary Trees
• Binary Search Tree
• Heaps/Priority Queues
• Trie (Keyword Tree)
• Segment Trees
• Fenwick (Binary Indexed) Trees
• Suffix Trees
• Suffix Arrays
• Basics of Disjoint Data Structures
• Linear Search
• Binary Search
• Ternary Search
• Bubble Sort
• Selection Sort
• Insertion Sort
• Counting Sort
• Bucket Sort
• Basics of Greedy Algorithms
• Graph Representation
• Breadth First Search
• Depth First Search
• Minimum Spanning Tree
• Shortest Path Algorithms
• Flood-fill Algorithm
• Articulation Points and Bridges
• Biconnected Components
• Strongly Connected Components
• Topological Sort
• Hamiltonian Path
• Maximum flow
• Minimum Cost Maximum Flow
• Basics of String Manipulation
• String Searching
• Z Algorithm
• Manachar’s Algorithm
• Introduction to Dynamic Programming 1
• 2 Dimensional
• State space reduction
• Dynamic Programming and Bit Masking
• Basic Number Theory-1
• Basic Number Theory-2
• Primality Tests
• Totient Function
• Basics of Combinatorics
• Inclusion-Exclusion
• Line Sweep Technique
• Line Intersection using Bentley Ottmann Algorithm
• Basic Probability Models and Rules
• Bayes’ rules, Conditional probability, Chain rule
• Discrete Random Variables
• Continuous Random Variables
• Practical Tutorial on Data Manipulation with Numpy and Pandas in Python
• Beginners Guide to Regression Analysis and Plot Interpretations
• Practical Guide to Logistic Regression Analysis in R
• Practical Tutorial on Random Forest and Parameter Tuning in R
• Practical Guide to Clustering Algorithms & Evaluation in R
• Beginners Tutorial on XGBoost and Parameter Tuning in R
• Deep Learning & Parameter Tuning with MXnet, H2o Package in R
• Decision Tree
• Simple Tutorial on Regular Expressions and String Manipulations in R
• Practical Guide to Text Mining and Feature Engineering in R
• Winning Tips on Machine Learning Competitions by Kazanova, Current Kaggle #3
• Practical Machine Learning Project in Python on House Prices Data
• Challenge #1 - Machine Learning
• Challenge #3 - Machine Learning
• Challenge #2 - Deep Learning
• Transfer Learning Introduction
• Input and Output
• Python Variables
• Conditionals
• Expressions
• Classes and Objects I
• Classes and Objects II (Inheritance and Composition)
• Errors and Exceptions
• Iterators and Generators
• Functional Programming
• Higher Order Functions and Decorators
• +1-650-461-4192
• For sales enquiry [email protected]
• For support [email protected]
• Campus Ambassadors
• Assessments
• Learning and Development
• Interview Prep
• Engineering Blog
• Privacy Policy
• © 2024 HackerEarth All rights reserved
• Terms of Service

• Admiral “Amazing Grace” Hopper

Exploring the Intricacies of NP-Completeness in Computer Science

Understanding p vs np problems in computer science: a primer for beginners, understanding key theoretical frameworks in computer science: a beginner’s guide.

Learn Computer Science with Python

CS is a journey, not a destination

• Foundations

Understanding Algorithms: The Key to Problem-Solving Mastery

The world of computer science is a fascinating realm, where intricate concepts and technologies continuously shape the way we interact with machines. Among the vast array of ideas and principles, few are as fundamental and essential as algorithms. These powerful tools serve as the building blocks of computation, enabling computers to solve problems, make decisions, and process vast amounts of data efficiently.

An algorithm can be thought of as a step-by-step procedure or a set of instructions designed to solve a specific problem or accomplish a particular task. It represents a systematic approach to finding solutions and provides a structured way to tackle complex computational challenges. Algorithms are at the heart of various applications, from simple calculations to sophisticated machine learning models and complex data analysis.

Understanding algorithms and their inner workings is crucial for anyone interested in computer science. They serve as the backbone of software development, powering the creation of innovative applications across numerous domains. By comprehending the concept of algorithms, aspiring computer science enthusiasts gain a powerful toolset to approach problem-solving and gain insight into the efficiency and performance of different computational methods.

In this article, we aim to provide a clear and accessible introduction to algorithms, focusing on their importance in problem-solving and exploring common types such as searching, sorting, and recursion. By delving into these topics, readers will gain a solid foundation in algorithmic thinking and discover the underlying principles that drive the functioning of modern computing systems. Whether you’re a beginner in the world of computer science or seeking to deepen your understanding, this article will equip you with the knowledge to navigate the fascinating world of algorithms.

What are Algorithms?

At its core, an algorithm is a systematic, step-by-step procedure or set of rules designed to solve a problem or perform a specific task. It provides clear instructions that, when followed meticulously, lead to the desired outcome.

Consider an algorithm to be akin to a recipe for your favorite dish. When you decide to cook, the recipe is your go-to guide. It lists out the ingredients you need, their exact quantities, and a detailed, step-by-step explanation of the process, from how to prepare the ingredients to how to mix them, and finally, the cooking process. It even provides an order for adding the ingredients and specific times for cooking to ensure the dish turns out perfect.

In the same vein, an algorithm, within the realm of computer science, provides an explicit series of instructions to accomplish a goal. This could be a simple goal like sorting a list of numbers in ascending order, a more complex task such as searching for a specific data point in a massive dataset, or even a highly complicated task like determining the shortest path between two points on a map (think Google Maps). No matter the complexity of the problem at hand, there’s always an algorithm working tirelessly behind the scenes to solve it.

Furthermore, algorithms aren’t limited to specific programming languages. They are universal and can be implemented in any language. This is why understanding the fundamental concept of algorithms can empower you to solve problems across various programming languages.

The Importance of Algorithms

Algorithms are indisputably the backbone of all computational operations. They’re a fundamental part of the digital world that we interact with daily. When you search for something on the web, an algorithm is tirelessly working behind the scenes to sift through millions, possibly billions, of web pages to bring you the most relevant results. When you use a GPS to find the fastest route to a location, an algorithm is computing all possible paths, factoring in variables like traffic and road conditions, to provide you the optimal route.

Consider the world of social media, where algorithms curate personalized feeds based on our previous interactions, or in streaming platforms where they recommend shows and movies based on our viewing habits. Every click, every like, every search, and every interaction is processed by algorithms to serve you a seamless digital experience.

In the realm of computer science and beyond, everything revolves around problem-solving, and algorithms are our most reliable problem-solving tools. They provide a structured approach to problem-solving, breaking down complex problems into manageable steps and ensuring that every eventuality is accounted for.

Moreover, an algorithm’s efficiency is not just a matter of preference but a necessity. Given that computers have finite resources — time, memory, and computational power — the algorithms we use need to be optimized to make the best possible use of these resources. Efficient algorithms are the ones that can perform tasks more quickly, using less memory, and provide solutions to complex problems that might be infeasible with less efficient alternatives.

In the context of massive datasets (the likes of which are common in our data-driven world), the difference between a poorly designed algorithm and an efficient one could be the difference between a solution that takes years to compute and one that takes mere seconds. Therefore, understanding, designing, and implementing efficient algorithms is a critical skill for any computer scientist or software engineer.

Hence, as a computer science beginner, you are starting a journey where algorithms will be your best allies — universal keys capable of unlocking solutions to a myriad of problems, big or small.

Common Types of Algorithms: Searching and Sorting

Two of the most ubiquitous types of algorithms that beginners often encounter are searching and sorting algorithms.

Searching algorithms are designed to retrieve specific information from a data structure, like an array or a database. A simple example is the linear search, which works by checking each element in the array until it finds the one it’s looking for. Although easy to understand, this method isn’t efficient for large datasets, which is where more complex algorithms like binary search come in.

Binary search, on the other hand, is like looking up a word in the dictionary. Instead of checking each word from beginning to end, you open the dictionary in the middle and see if the word you’re looking for should be on the left or right side, thereby reducing the search space by half with each step.

Sorting algorithms, meanwhile, are designed to arrange elements in a particular order. A simple sorting algorithm is bubble sort, which works by repeatedly swapping adjacent elements if they’re in the wrong order. Again, while straightforward, it’s not efficient for larger datasets. More advanced sorting algorithms, such as quicksort or mergesort, have been designed to sort large data collections more efficiently.

Diving Deeper: Graph and Dynamic Programming Algorithms

Building upon our understanding of searching and sorting algorithms, let’s delve into two other families of algorithms often encountered in computer science: graph algorithms and dynamic programming algorithms.

A graph is a mathematical structure that models the relationship between pairs of objects. Graphs consist of vertices (or nodes) and edges (where each edge connects a pair of vertices). Graphs are commonly used to represent real-world systems such as social networks, web pages, biological networks, and more.

Graph algorithms are designed to solve problems centered around these structures. Some common graph algorithms include:

Dynamic programming is a powerful method used in optimization problems, where the main problem is broken down into simpler, overlapping subproblems. The solutions to these subproblems are stored and reused to build up the solution to the main problem, saving computational effort.

Here are two common dynamic programming problems:

Understanding these algorithm families — searching, sorting, graph, and dynamic programming algorithms — not only equips you with powerful tools to solve a variety of complex problems but also serves as a springboard to dive deeper into the rich ocean of algorithms and computer science.

Recursion: A Powerful Technique

While searching and sorting represent specific problem domains, recursion is a broad technique used in a wide range of algorithms. Recursion involves breaking down a problem into smaller, more manageable parts, and a function calling itself to solve these smaller parts.

To visualize recursion, consider the task of calculating factorial of a number. The factorial of a number n (denoted as n! ) is the product of all positive integers less than or equal to n . For instance, the factorial of 5 ( 5! ) is 5 x 4 x 3 x 2 x 1 = 120 . A recursive algorithm for finding factorial of n would involve multiplying n by the factorial of n-1 . The function keeps calling itself with a smaller value of n each time until it reaches a point where n is equal to 1, at which point it starts returning values back up the chain.

Algorithms are truly the heart of computer science, transforming raw data into valuable information and insight. Understanding their functionality and purpose is key to progressing in your computer science journey. As you continue your exploration, remember that each algorithm you encounter, no matter how complex it may seem, is simply a step-by-step procedure to solve a problem.

We’ve just scratched the surface of the fascinating world of algorithms. With time, patience, and practice, you will learn to create your own algorithms and start solving problems with confidence and efficiency.

Related Articles

Three Elegant Algorithms Every Computer Science Beginner Should Know

EnjoyMathematics

Steps of Problem Solving in Data Structures and Algorithms

Every solution starts with a strategy, and an algorithm is a strategy for solving a coding problem. So, we must learn to design an efficient algorithm and translate this 'algorithm' into the correct code to get the job done.

But there are many coding problems available in data structures and algorithms, and most of the time, these problems are new to us. So as programmers, we need to develop ourselves as confident problem-solvers who are not intimidated by the difficulty of the given problem. 

Our long-term goal should be simple: Learn to design correct and efficient code within a given time. As we practice more and more, we will gain experience in problem-solving, and our work will become easier. Here are some essential skills that we should practice for every DSA problem:

• Developing an approach to understanding the problem
• Thinking of a correct basic solution
• Designing step-by-step pseudocode solutions
• Analyzing the efficiency of a solution
• Optimizing the solution further
• Transforming pseudocode into correct code

Now, the critical question would be: Is there a well-defined, guided strategy to approach and solve a coding problem? If yes, then what are the critical steps? Let's think and explore!

Step 1: Understanding the problem

Solving a problem requires a clear understanding of the problem. Unfortunately, sometimes we read only the first few lines and assume the rest of the problem or ignore this step because we have seen something similar in the past. We should view these as unfair practices and develop a clear approach to understanding problems.

During problem-solving, every small detail can help us design an efficient solution. Sometimes, a small change in the question can alter the solution approach. Taking extra time to understand the problem will give us more confidence later on. The fact is, we never want to realize halfway through that we misunderstood the problem.

It doesn't matter if we have encountered a question before or not; we should read the question several times. So, take a paper and write down everything while going through the problem. Exploring some examples will also help us clarify how many cases our algorithm can handle and the possible input-output patterns. We should also explore scenarios for large input, edge cases, and invalid input.

Sometimes, it is common for problem descriptions to suffer from these types of deficiencies:

• The problem description may rely on undefined assumptions
• The problem description may be ambiguous or incomplete
• The problem description may have various contradictions.

These deficiencies may be due to the abstract explanation of the problem description in our natural languages. So, it is our responsibility to identify such deficiencies and work with the interviewer or problem provider to clarify them. We should start by seeking answers to the following questions:

• What are the inputs and outputs?
• What type of data is available?
• What is the size or scale of the input?
• How is the data stored? What is the data structure?
• Are there any special conditions or orders in the data?
• What rules exist for working with the data?

Step 2: Thinking of a correct basic solution

The best approach would be to think of a correct solution that comes immediately to our mind. It does not matter even if it is an inefficient approach. Having a correct and inefficient answer is much better than an incorrect solution or significant delay in finding the solution. This could help us in so many ways:

• Help us to build good confidence or motivation at the start.
• Provide an excellent point to start a conversation with the interviewer.
• Sometimes, it provides a hint to improve efficiency by reducing some loops, removing some intermediate steps, or performing some operations efficiently.

Here are some examples of brute force patterns: three nested loops, two nested loops, solution using extra memory, solution using sorting, double traversal in the binary tree, considering all sub-arrays or substrings, exhaustive search, etc.

After thinking and communicating the brute force idea, the interviewer may ask for its time and space complexity. We need to work on paper, analyze each critical operation, and write it in the form of Big-O notation. Clear conceptual idea of time and space complexity analysis is essential at this stage.

Step 3: Designing efficient solution with pseudocode

This is a stage to use the best experience of DSA problem-solving and apply various problem-solving strategies . One practical truth is: moving from a basic algorithm to the most efficient algorithm is a little difficult in a single step. Each time, we need to optimize the previous algorithm and stop when there is no further optimization possible. Revisiting the problem description and looking for some additional information can help a lot in further optimization. For example:

• If the input array is sorted or nearly sorted, we can apply optimized algorithms such as a single loop, two-pointer approach, or binary search.
• If we need to find a subarray of size k, we can use the sliding window technique, which involves maintaining a window of size k over the array and sliding it over the elements to find the desired subarray.
• When searching is a critical operation, we can use optimized search algorithms or data structures like binary search, BST, or hash table.
• For optimization problems, we can consider divide and conquer, dynamic programming, or greedy algorithm approaches.
• If we need to find a solution with a given constraint, we can use backtracking.
• When working with string data, direct address tables, hash tables, or trie data structures can be useful.
• To frequently access and process max or min elements, we can use a priority queue or heap data structure.
• For dictionary operations such as insert, search, and delete, we can use hash tables or BST.
• If we need to perform both dictionary and priority queue operations, a BST may be useful.
• For range query operations such as range max, range min, or range sum, we can use data structures like segment trees or Fenwick trees.
• To process binary tree data level by level, BFS or level-order traversal can be used.

The idea would be simple: we should learn the use case of efficient problem-solving patterns on various data structures. Continuously thinking, analyzing, and looking for a better solution is the core idea. 

Here are some best examples of problems where several levels of optimisations are feasible. Practicing such types of coding questions helps a lot in building confidence.

Find equilibrium index of an array

• Using nested loops: Time = O(n²), Memory = O(1)
• Using prefix sum array: Time = O(n), Memory = O(n)
• Using single scan: Time = O(n), Memory = O(1)

Trapping rain water

• Using Dynamic Programming: Time = O(n), Memory = O(n)
• Using Stack: Time = O(n), Memory = O(n)
• Using two pointers: Time = O(n), Memory = O(1)

Check for pair with a given sum

• Using sorting and binary search: Time = O(nlogn), Memory = O(1)
• Using sorting and Two Pointers: Time = O(nlogn), Memory = O(1)
• Using a Hash Table: Time = O(n), Memory = O(n)

Find the majority element in an array

• Using two nested loops: Time = O(n²), Memory = O(1)
• Using Sorting: Time = O(nlogn), Memory = O(1)
• Using the divide and conquer: Time = O(nlogn), Memory = O(logn)
• Using Bit Manipulation: Time = O(n), Memory = O(1)
• Using Randomisation: Time = O(nlogn), Memory = O(1) Note: If value of n is very large.
• Boyer-Moore Voting Algorithm: Time = O(n), Memory = O(1)

Maximum Subarray Sum

• Using three nested loops: Time = O(n^3), Memory = O(1)
• Using two nested loops: Time = O(n^2), Memory = O(1)
• Using divide and conquer: Time = O(nlogn), Memory = O(logn)
• Using dynamic programming: Time = O(n), Memory = O(n)
• Kadane algorithm: Time = O(n), Memory = O(1)

Before you jump into the end-to-end code implementation, it’s good practice to write pseudocode on paper. It would be helpful in defining code structure and critical operations. Some programmers skip this step, but writing the final code becomes easier when we have well-designed pseudocode.

Step 4: Transforming pseudocode into a clean, correct, and optimized code

Finally, we need to replace each line of pseudocode with actual code in our favorite programming languages like C++, Java, Python, C#, JavaScript, etc. Never forget to test actual code with sample test data and check if the actual output is equal to the expected output. When writing code in your interviews, discuss sample data or test cases with the interviewer.

Simplifying and optimizing the code may require a few iterations of observation. We need to ask these questions once we are done writing the code: 

• Does this code run for every possible input, including the edge cases?
• Can we optimize the code further? Can we remove some variables or loop or some extra space?
• Are we repeating some steps a lot? Can we define it separately using another function?
• Is the code readable or written with a good coding style?

Enjoy learning, Enjoy coding, Enjoy algorithms!

More from EnjoyAlgorithms

Self-paced courses and blogs.

DEV Community

Posted on Mar 23, 2019 • Updated on Jan 28, 2023

50+ Data Structure and Algorithms Problems from Coding Interviews

Disclosure: This post includes affiliate links; I may receive compensation if you purchase products or services from the different links provided in this article.

There are a lot of computer science graduates and programmers applying for programming, coding, and software development roles at startups like Uber and Netflix; big organizations like Amazon , Microsoft , and Google ; and service-based companies like Infosys or Luxsoft, but many of them have no idea of what kind of programming interview questions to expect when you're applying for a job with these companies.

In this article, I'll share some frequently asked programming interview questions from different Job interviews for programmers at different levels of experience,from people who have just graduated from college to programmers with one to two years of experience.

Coding interviews are comprised mainly of d ata structure and algorithm-based questions as well as some of the logical questions such as, How do you swap two integers without using a temporary variable?

I think it's helpful to divide coding interview questions into different topic areas.

The topic areas I've seen most often in interviews are array , linked list , string , binary tree , as well as questions from algorithms like string algorithm, sorting algorithms like quicksort or radix sort , and other miscellaneous ones), and that's what you will find in this article.

It's not guaranteed that you will be asked these coding or data structure and algorithmic questions, but they will give you enough of an idea of the kinds of questions you can expect in a real programming job interview.

Once you have gone through these questions, you should feel confident enough to attend any telephonic or face-to-face interviews.

Btw, there is no point in attempting these questions if you don't have sufficient knowledge of essential Data Structure and Algorithms or you have not touched them for ages.

In that case, you should take a good introductory course like Data Structures and Algorithms: Deep Dive Using Java to refresh your DS and algorithms skills.

Top 50 Algorithms and Coding Interview Questions

Without any further ado, here is my list of some of the most frequently asked coding interview questions from programming job interviews :

1. Array Coding Interview Questions

An array is the most fundamental data structure, which stores elements at a contiguous memory location. It is also one of the darling topics of interviewers and you will hear a lot of questions about an array in any coding interview , like reversing an array, sorting the array, or searching elements on the array.

The key benefit of an array data structure is that it offers fast O(1) search if you know the index, but adding and removing an element from an array is slow because you cannot change the size of the array once it's created.

In order to create a shorter or longer array, you need to create a new array and copy all elements from old to new.

The key to solving array-based questions is having a good knowledge of array data structure as well as basic programming constructors such as loop, recursion, and fundamental operators.

Here are some tips to solve array based coding problems:

• array index starts at zero
• You can use loops to iterate over array
• array elements are stored in contiguous memory location so you can also access them using pointer arithmetic
• Array provides O(1) performance for search using index
• Adding or removing elements are slower in array due to re-sizing

Here are some of the popular array-based coding interview questions for your practice:

• How do you find the missing number in a given integer array of 1 to 100 ? ( solution )
• How do you find the duplicate number on a given integer array? ( solution )
• How do you find the largest and smallest number in an unsorted integer array? ( solution )
• How do you find all pairs of an integer array whose sum is equal to a given number?( solution )
• How do you find duplicate numbers in an array if it contains multiple duplicates?( solution )
• How are duplicates removed from a given array in Java? ( solution )
• How is an integer array sorted in place using the quicksort algorithm? ( solution )
• How do you remove duplicates from an array in place? ( solution )
• How do you reverse an array in place in Java? ( solution )
• How are duplicates removed from an array without using any library? ( solution )

These questions will not only help you to develop your problem-solving skills but also improve your knowledge of the array data structure.

If you need more advanced questions based upon array then you can see also see The Coding Interview Bootcamp: Algorithms + Data Structures , a Bootcamp style course on algorithms, especially designed for interview preparation to get a job on technical giants like Google, Microsoft, Apple, Facebook, etc.

And, if you feel 10 is not enough questions and you need more practice, then you can also check out this list of 30 array questions .

2. Linked List Programming Interview Questions

A linked list is another common data structure that complements the array data structure. Similar to the array, it is also a linear data structure and stores elements in a linear fashion.

However, unlike the array, it doesn't store them in contiguous locations; instead, they are scattered everywhere in memory, which is connected to each other using nodes.

A linked list is nothing but a list of nodes where each node contains the value stored and the address of the next node.

Because of this structure, it's easy to add and remove elements in a linked list , as you just need to change the link instead of creating the array, but the search is difficult and often requires O(n) time to find an element in the singly linked list.

This article provides more information on the difference between an array and linked list data structures.

It also comes in varieties like a singly linked list, which allows you to traverse in one direction (forward or reverse); a doubly linked list , which allows you to traverse in both directions (forward and backward); and finally, the circular linked list, which forms a circle.

In order to solve linked list-based questions, a good knowledge of recursion is important, because a linked list is a recursive data structure .

If you take one node from a linked list, the remaining data structure is still a linked list, and because of that, many linked list problems have simpler recursive solutions than iterative ones.

Here are some of the most common and popular linked list interview questions and their solutions:

• How do you find the middle element of a singly linked list in one pass? ( solution )
• How do you check if a given linked list contains a cycle? How do you find the starting node of the cycle? ( solution )
• How do you reverse a linked list? ( solution )
• How do you reverse a singly linked list without recursion? ( solution )
• How are duplicate nodes removed in an unsorted linked list? ( solution )
• How do you find the length of a singly linked list? ( solution )
• How do you find the third node from the end in a singly linked list? ( solution )
• How do you find the sum of two linked lists using Stack? ( solution )

These questions will help you to develop your problem-solving skills as well as improve your knowledge of the linked list data structure.

If you are having trouble solving these linked list coding questions then I suggest you refresh your data structure and algorithms skill by going through Data Structures and Algorithms: Deep Dive ** Using Java** course.

You can also check out this list of 30 linked list interview questions for more practice questions.

3. String Coding Interview Questions

Along with array and linked list data structures, a string is another popular topic on programming job interviews. I have never participated in a coding interview where no string-based questions were asked.

A good thing about the string is that if you know the array, you can solve string-based questions easily because strings are nothing but a character array .

So all the techniques you learn by solving array-based coding questions can be used to solve string programming questions as well.

Here is my list of frequently asked string coding questions from programming job interviews:

• How do you print duplicate characters from a string? ( solution )
• How do you check if two strings are anagrams of each other? ( solution )
• How do you print the first non-repeated character from a string? ( solution )
• How can a given string be reversed using recursion? ( solution )
• How do you check if a string contains only digits? ( solution )
• How are duplicate characters found in a string? ( solution )
• How do you count a number of vowels and consonants in a given string? ( solution )
• How do you count the occurrence of a given character in a string? ( solution )
• How do you find all permutations of a string? ( solution )
• How do you reverse words in a given sentence without using any library method? ( solution )
• How do you check if two strings are a rotation of each other? ( solution )
• How do you check if a given string is a palindrome? ( solution )

These questions help improve your knowledge of string as a data structure. If you can solve all these String questions without any help then you are in good shape.

For more advanced questions, I suggest you solve problems given in the Algorithm Design Manual by Steven Skiena , a book with the toughest algorithm questions.

If you need more practice, here is another list of 20 string coding questions .

4. Binary Tree Coding Interview Questions

So far, we have looked at only the linear data structure, but all information in the real world cannot be represented in a linear fashion, and that's where tree data structure helps.

The tree data structure is a data structure that allows you to store your data in a hierarchical fashion. Depending on how you store data, there are different types of trees, such as a binary tree , where each node has, at most, two child nodes.

Along with its close cousin binary search tree , it's also one of the most popular tree data structures. Therefore, you will find a lot of questions based on them, such as how to traverse them, count nodes, find depth, and check if they are balanced or not.

A key point to solving binary tree questions is a strong knowledge of theory, like what is the size or depth of the binary tree, what is a leaf, and what is a node, as well as an understanding of the popular traversing algorithms, like pre-, post-, and in-order traversal.

Here is a list of popular binary tree-based coding questions from software engineer or developer job interviews:

• How is a binary search tree implemented? ( solution )
• How do you perform preorder traversal in a given binary tree?( solution )
• How do you traverse a given binary tree in preorder without recursion?( solution )
• How do you perform an inorder traversal in a given binary tree?*( solution )
• How do you print all nodes of a given binary tree using inorder traversal without recursion? ( solution )
• How do you implement a postorder traversal algorithm? ( solution )
• How do you traverse a binary tree in postorder traversal without recursion?( solution )
• How are all leaves of a binary search tree printed?( solution )
• How do you count a number of leaf nodes in a given binary tree?( solution )
• How do you perform a binary search in a given array?( solution )

If you feel that your understanding of binary tree coding is inadequate and you can't solve these questions on your own, I suggest you go back and pick a good data structure and algorithm course like From 0 to 1: Data Structures & Algorithms in Java .

If you need some more recommendations, here is my list of useful data structure algorithm books and courses to start with.

5. Miscellaneous Coding Interview Questions

Apart from data structure-based questions, most of the programming job interviews also ask algorithms , software design , bit manipulation, and general logic-based questions, which I'll describe in this section.

It's important that you practice these concepts because sometimes they become tricky to solve in the actual interview. Having practiced them before not only makes you familiar with them but also gives you more confidence in explaining the solution to the interviewer.

• How is a bubble sort algorithm implemented? ( solution )
• How is an iterative quicksort algorithm implemented? ( solution )
• How do you implement an insertion sort algorithm? ( solution )
• How is a merge sort algorithm implemented? ( solution )
• How do you implement a bucket sort algorithm?( solution )
• How do you implement a counting sort algorithm?( solution )
• How is a radix sort algorithm implemented?( solution )
• How do you swap two numbers without using the third variable? ( solution )
• How do you check if two rectangles overlap with each other? ( solution )
• How do you design a vending machine? ( solution )

If you need more such coding questions you can take help from books like Cracking The Code Interview , by Gayle Laakmann McDowell which presents 189+ Programming questions and solution. A good book to prepare for programming job interviews in a short time.

By the way, the more questions you solve in practice, the better your preparation will be. So, if you think 50 is not enough and you need more, then check out these additional 50 programming questions for telephone interviews and these books and courses for more thorough preparation.

Now You're Ready for the Coding Interview

These are some of the most common questions outside of data structure and algorithms that help you to do really well in your interview.

I have also shared a lot of these questions on my blog , so if you are really interested, you can always go there and search for them.

These common coding, data structure, and algorithm questions are the ones you need to know to successfully interview with any company, big or small, for any level of programming job.

If you are looking for a programming or software development job, you can start your preparation with this list of coding questions.

This list provides good topics to prepare and also helps assess your preparation to find out your areas of strength and weakness.

Good knowledge of data structure and algorithms is important for success in coding interviews and that's where you should focus most of your attention.

Further Learning Data Structures and Algorithms: Deep Dive Using Java Master the Coding Interview: Data Structures + Algorithms by Andrei Negaoie Grokking the Coding Interview: Patterns for Coding Questions Algorithms and Data Structures - Part 1 and 2 10 Books to Prepare Technical Programming/Coding Job Interviews 10 Algorithm Books Every Programmer Should Read Top 5 Data Structure and Algorithm Books for Java Developers From 0 to 1: Data Structures & Algorithms in Java Data Structure and Algorithms Analysis --- Job Interview

Closing Notes

Thanks, You made it to the end of the article ... Good luck with your programming interview! It's certainly not going to be easy, but by following this roadmap and guide, you are one step closer to becoming a DevOps engineer .

If you like this article, then please share it with your friends and colleagues, and don't forget to follow javinpaul on Twitter!

P.S. --- If you need some FREE resources, you can check out this list of free data structure and algorithm courses to start your preparation.

Top comments (16).

Templates let you quickly answer FAQs or store snippets for re-use.

• Location Bengaluru, India
• Work Full Stack Developer at Hashnode
• Joined Mar 6, 2019

This article is like a Gold mine for me. Thanks a lot

• Joined Sep 16, 2018

Thanks Mohd Shad Mirza

• Location Perth, Western Australia
• Education Moscow Aviation Institute
• Work Founder at FullStack.Cafe
• Joined Jul 14, 2018

Thanks a lot for the article, it's very helpful! For more Data Structures and Coding Interview Questions check my blog posts on fullstack.cafe . Hope it will help anyone to crack your next coding interview!

• Location New Delhi
• Joined Feb 23, 2022

GOF Academy is one of the Best IIT, Neet Coaching Institute in Kalu Sarai, Live Coaching Classes For Neet Preparation. Enquire Now For Admission Fees gofacademy.in/iit-coaching-in-kalu...

Are you preparing for competitive exams like IIT, NEET, NTSE, Olympiads, KVPY, UPSC or JEE? You must be looking for best coaching institute in Delhi, which can guide you in your competitive exam preparation. Aspirant must opt for GOF Academy that serves as the best IIT Coaching institutes in Delhi providing one stop exam solutions with study material, test series, and lectures. Our highly experienced faculties put in great efforts to clear the concept in aspirant’s mind with their short tricks. With the utmost support of lecturers and state of the art educational infrastructures, we are able to provide high-quality engineering education. If you searching for coaching institute in Delhi for IIT-JEE, NEET and foundation course, Call at 8700484442 to book your slot. Admission open, Limited Seats. Visit gofacademy.in

• Location Mumbai
• Education CSE Undegrad Student at Mumbai University
• Joined Sep 14, 2020

Thanks a lot

• Joined Jun 9, 2021

Hello. How can I initialize objects like Arrays, List in a constructor?

• Location Pune
• Education BE IT, MBA Systems Mgmt.
• Work Technical Lead at BNT Soft Pvt Ltd.
• Joined Feb 22, 2020

Thanks for sharing.

• Email [email protected]
• Joined Jul 14, 2022

Thanks for your content!

• Email [email protected]
• Location India
• Education Sir Padampat Singhania University
• Work Student | Most of the time i am teacher to myself. ( A Strict one)
• Joined Oct 8, 2021

dev.to/ukantjadia/day-07-2doo

• Joined Jan 23, 2019

another awesome article :D

let me know what you think about this:

udemy.com/course/leetcode-in-pytho...

Some comments may only be visible to logged-in visitors. Sign in to view all comments.

Are you sure you want to hide this comment? It will become hidden in your post, but will still be visible via the comment's permalink .

Hide child comments as well

For further actions, you may consider blocking this person and/or reporting abuse

Resolve Content Security Policy (CSP) Issues in Your Discord Activity Using a Node.js Proxy

WavePlay Staff - Jun 17

From Noise to Art: Building Your First Generative Adversarial Network

yuval mehta - Jun 17

File locking vs Row Level Locking

dwivedialind - Jun 17

Abstract Classes

Paul Ngugi - Jun 17

We're a place where coders share, stay up-to-date and grow their careers.

What is Problem Solving Algorithm?, Steps, Representation

Table of Contents

• 1 What is Problem Solving Algorithm?
• 2 Definition of Problem Solving Algorithm
• 3.1 Analysing the Problem
• 3.2 Developing an Algorithm
• 3.4 Testing and Debugging
• 4.1 Flowchart
• 4.2 Pseudo code

What is Problem Solving Algorithm?

Computers are used for solving various day-to-day problems and thus problem solving is an essential skill that a computer science student should know. It is pertinent to mention that computers themselves cannot solve a problem. Precise step-by-step instructions should be given by us to solve the problem.

Thus, the success of a computer in solving a problem depends on how correctly and precisely we define the problem, design a solution (algorithm) and implement the solution (program) using a programming language.

Thus, problem solving is the process of identifying a problem, developing an algorithm for the identified problem and finally implementing the algorithm to develop a computer program.

Definition of Problem Solving Algorithm

These are some simple definition of problem solving algorithm which given below:

Steps for Problem Solving

When problems are straightforward and easy, we can easily find the solution. But a complex problem requires a methodical approach to find the right solution. In other words, we have to apply problem solving techniques.

Problem solving begins with the precise identification of the problem and ends with a complete working solution in terms of a program or software. Key steps required for solving a problem using a computer.

For Example: Suppose while driving, a vehicle starts making a strange noise. We might not know how to solve the problem right away. First, we need to identify from where the noise is coming? In case the problem cannot be solved by us, then we need to take the vehicle to a mechanic.

The mechanic will analyse the problem to identify the source of the noise, make a plan about the work to be done and finally repair the vehicle in order to remove the noise. From the example, it is explicit that, finding the solution to a problem might consist of multiple steps.

Following are Steps for Problem Solving :

Analysing the Problem

Developing an algorithm, testing and debugging.

It is important to clearly understand a problem before we begin to find the solution for it. If we are not clear as to what is to be solved, we may end up developing a program which may not solve our purpose.

Thus, we need to read and analyse the problem statement carefully in order to list the principal components of the problem and decide the core functionalities that our solution should have. By analysing a problem, we would be able to figure out what are the inputs that our program should accept and the outputs that it should produce.

It is essential to device a solution before writing a program code for a given problem. The solution is represented in natural language and is called an algorithm. We can imagine an algorithm like a very well-written recipe for a dish, with clearly defined steps that, if followed, one will end up preparing the dish.

We start with a tentative solution plan and keep on refining the algorithm until the algorithm is able to capture all the aspects of the desired solution. For a given problem, more than one algorithm is possible and we have to select the most suitable solution.

After finalising the algorithm, we need to convert the algorithm into the format which can be understood by the computer to generate the desired solution. Different high level programming languages can be used for writing a program. It is equally important to record the details of the coding procedures followed and document the solution. This is helpful when revisiting the programs at a later stage.

The program created should be tested on various parameters. The program should meet the requirements of the user. It must respond within the expected time. It should generate correct output for all possible inputs. In the presence of syntactical errors, no output will be obtained. In case the output generated is incorrect, then the program should be checked for logical errors, if any.

Software industry follows standardised testing methods like unit or component testing, integration testing, system testing, and acceptance testing while developing complex applications. This is to ensure that the software meets all the business and technical requirements and works as expected.

The errors or defects found in the testing phases are debugged or rectified and the program is again tested. This continues till all the errors are removed from the program. Once the software application has been developed, tested and delivered to the user, still problems in terms of functioning can come up and need to be resolved from time to time.

The maintenance of the solution, thus, involves fixing the problems faced by the user, answering the queries of the user and even serving the request for addition or modification of features.

Representation of Algorithms

Using their algorithmic thinking skills, the software designers or programmers analyse the problem and identify the logical steps that need to be followed to reach a solution. Once the steps are identified, the need is to write down these steps along with the required input and desired output.

There are two common methods of representing an algorithm —flowchart and pseudocode. Either of the methods can be used to represent an algorithm while keeping in mind the following:

• It showcases the logic of the problem solution, excluding any implementational details.
• It clearly reveals the flow of control during execution of the program.

A flowchart is a visual representation of an algorithm . A flowchart is a diagram made up of boxes, diamonds and other shapes, connected by arrows. Each shape represents a step of the solution process and the arrow represents the order or link among the steps.

A flow chart is a step by step diagrammatic representation of the logic paths to solve a given problem. Or A flowchart is visual or graphical representation of an algorithm .

The flowcharts are pictorial representation of the methods to b used to solve a given problem and help a great deal to analyze the problem and plan its solution in a systematic and orderly manner. A flowchart when translated in to a proper computer language, results in a complete program.

Advantages of Flowcharts:

• The flowchart shows the logic of a problem displayed in pictorial fashion which felicitates easier checking of an algorithm
• The Flowchart is good means of communication to other users. It is also a compact means of recording an algorithm solution to a problem.
• The flowchart allows the problem solver to break the problem into parts. These parts can be connected to make master chart.
• The flowchart is a permanent record of the solution which can be consulted at a later time.

Differences between Algorithm and Flowchart

Pseudo code

The Pseudo code is neither an algorithm nor a program. It is an abstract form of a program. It consists of English like statements which perform the specific operations. It is defined for an algorithm. It does not use any graphical representation.

In pseudo code , the program is represented in terms of words and phrases, but the syntax of program is not strictly followed.

Advantages of Pseudocode

• Before writing codes in a high level language, a pseudocode of a program helps in representing the basic functionality of the intended program.
• By writing the code first in a human readable language, the programmer safeguards against leaving out any important step. Besides, for non-programmers, actual programs are difficult to read and understand.
• But pseudocode helps them to review the steps to confirm that the proposed implementation is going to achieve the desire output.

Leave a Reply Cancel reply

Save my name, email, and website in this browser for the next time I comment.

Smart. Open. Grounded. Inventive. Read our Ideas Made to Matter.

Which program is right for you?

Through intellectual rigor and experiential learning, this full-time, two-year MBA program develops leaders who make a difference in the world.

A rigorous, hands-on program that prepares adaptive problem solvers for premier finance careers.

A 12-month program focused on applying the tools of modern data science, optimization and machine learning to solve real-world business problems.

Earn your MBA and SM in engineering with this transformative two-year program.

Combine an international MBA with a deep dive into management science. A special opportunity for partner and affiliate schools only.

A doctoral program that produces outstanding scholars who are leading in their fields of research.

Bring a business perspective to your technical and quantitative expertise with a bachelor’s degree in management, business analytics, or finance.

A joint program for mid-career professionals that integrates engineering and systems thinking. Earn your master’s degree in engineering and management.

An interdisciplinary program that combines engineering, management, and design, leading to a master’s degree in engineering and management.

Executive Programs

A full-time MBA program for mid-career leaders eager to dedicate one year of discovery for a lifetime of impact.

This 20-month MBA program equips experienced executives to enhance their impact on their organizations and the world.

Non-degree programs for senior executives and high-potential managers.

A non-degree, customizable program for mid-career professionals.

Gensler exec: ‘Amplify your impact as you advance your career’

How can we preserve human ability in the age of machines?

Want to invest wisely? Check your prior beliefs at the door

Credit: Alejandro Giraldo

Ideas Made to Matter

How to use algorithms to solve everyday problems

Kara Baskin

May 8, 2017

How can I navigate the grocery store quickly? Why doesn’t anyone like my Facebook status? How can I alphabetize my bookshelves in a hurry? Apple data visualizer and MIT System Design and Management graduate Ali Almossawi solves these common dilemmas and more in his new book, “ Bad Choices: How Algorithms Can Help You Think Smarter and Live Happier ,” a quirky, illustrated guide to algorithmic thinking. 

For the uninitiated: What is an algorithm? And how can algorithms help us to think smarter?

An algorithm is a process with unambiguous steps that has a beginning and an end, and does something useful.

Algorithmic thinking is taking a step back and asking, “If it’s the case that algorithms are so useful in computing to achieve predictability, might they also be useful in everyday life, when it comes to, say, deciding between alternative ways of solving a problem or completing a task?” In all cases, we optimize for efficiency: We care about time or space.

Note the mention of “deciding between.” Computer scientists do that all the time, and I was convinced that the tools they use to evaluate competing algorithms would be of interest to a broad audience.

Why did you write this book, and who can benefit from it?

All the books I came across that tried to introduce computer science involved coding. My approach to making algorithms compelling was focusing on comparisons. I take algorithms and put them in a scene from everyday life, such as matching socks from a pile, putting books on a shelf, remembering things, driving from one point to another, or cutting an onion. These activities can be mapped to one or more fundamental algorithms, which form the basis for the field of computing and have far-reaching applications and uses.

I wrote the book with two audiences in mind. One, anyone, be it a learner or an educator, who is interested in computer science and wants an engaging and lighthearted, but not a dumbed-down, introduction to the field. Two, anyone who is already familiar with the field and wants to experience a way of explaining some of the fundamental concepts in computer science differently than how they’re taught.

I’m going to the grocery store and only have 15 minutes. What do I do?

Do you know what the grocery store looks like ahead of time? If you know what it looks like, it determines your list. How do you prioritize things on your list? Order the items in a way that allows you to avoid walking down the same aisles twice.

For me, the intriguing thing is that the grocery store is a scene from everyday life that I can use as a launch pad to talk about various related topics, like priority queues and graphs and hashing. For instance, what is the most efficient way for a machine to store a prioritized list, and what happens when the equivalent of you scratching an item from a list happens in the machine’s list? How is a store analogous to a graph (an abstraction in computer science and mathematics that defines how things are connected), and how is navigating the aisles in a store analogous to traversing a graph?

Nobody follows me on Instagram. How do I get more followers?

The concept of links and networks, which I cover in Chapter 6, is relevant here. It’s much easier to get to people whom you might be interested in and who might be interested in you if you can start within the ball of links that connects those people, rather than starting at a random spot.

You mention Instagram: There, the hashtag is one way to enter that ball of links. Tag your photos, engage with users who tag their photos with the same hashtags, and you should be on your way to stardom.

What are the secret ingredients of a successful Facebook post?

I’ve posted things on social media that have died a sad death and then posted the same thing at a later date that somehow did great. Again, if we think of it in terms that are relevant to algorithms, we’d say that the challenge with making something go viral is really getting that first spark. And to get that first spark, a person who is connected to the largest number of people who are likely to engage with that post, needs to share it.

With [my first book], “Bad Arguments,” I spent a month pouring close to $5,000 into advertising for that project with moderate results. And then one science journalist with a large audience wrote about it, and the project took off and hasn’t stopped since.

What problems do you wish you could solve via algorithm but can’t?

When we care about efficiency, thinking in terms of algorithms is useful. There are cases when that’s not the quality we want to optimize for — for instance, learning or love. I walk for several miles every day, all throughout the city, as I find it relaxing. I’ve never asked myself, “What’s the most efficient way I can traverse the streets of San Francisco?” It’s not relevant to my objective.

Algorithms are a great way of thinking about efficiency, but the question has to be, “What approach can you optimize for that objective?” That’s what worries me about self-help: Books give you a silver bullet for doing everything “right” but leave out all the nuances that make us different. What works for you might not work for me.

Which companies use algorithms well?

When you read that the overwhelming majority of the shows that users of, say, Netflix, watch are due to Netflix’s recommendation engine, you know they’re doing something right.

Related Articles

Algorithms and Problem Solving ​

Algorithms and flowcharts (designing a program) ​.

Reference this presentation for your first homework.

Five Simple Ideas Used to Create All Programs ​

• A list of instructions performed in order
• If…, then…, else…
• Repeated behavior (i.e., while there are cookies on the plate, keep eating cookies)
• Breaking the problem into sub-problems that can be solved independently.
• A set of instructions that return a single result (answer a question).

Complexity ​

Most computers only really “understand” about 100 different instructions.

Powerful applications take advantage of the extreme number of possible instruction combinations.

Chess is a good analogy:

• 6 types of pieces; each piece moves in a simple pattern.
• Possible/playable chess games (assuming an avg. game has 30 moves) are 4,670,033.

Algorithms ​

An algorithm is A step-by-step list of instructions for solving a problem. The solution must be determined in a finite amount of time.

Algorithms can be expressed in many kinds of notations (e.g., natural language, pseudocode, flowcharts, etc.)

Flowcharts ​

A flowchart is one way to represent an algorithm and uses the following symbols.

Creating Solutions ​

• Step-by-step problem-solving process
• In a finite amount of time
• Programming is a process of problem-solving.

Programming with the Problem Analysis–Coding–Execution Cycle ​

Analyze the problem

• Does the program require user interaction?
• Does the program manipulate data?
• What is the output?
• Analyze and design algorithms for each subproblem
• Can test using sample data
• Some mathematical analysis might be required

Implement the algorithm

• Enter the program using a text editor. This is called the implementation of the algorithm.
• Compile code
• Look at the code and remove errors
• Run code again through the compiler
• The compiler guarantees that the program follows the rules of the language. It does not guarantee that the program will run correctly.
• Linker links machine code with system resources

Execution (run the compiles program)

• Once compiled and linked, the loader can place the program into the main memory for execution.
• The final step is to execute the program.

Maintenance

• Use and modify the program if the problem domain changes.

Programming Methods ​

Two popular approaches to programming design

• Structured (e.g., Procedural)
• Object-oriented

There are many other programming paradigms .

Structured Programming ​

Procedural design is a subset of structured design:

• Dividing a problem into smaller subproblems
• A solution to a subproblem is a “module” or “procedure” and is simply a series of computation steps to be carried out.
• Top-down (or bottom-up) design
• Stepwise refinement
• Modular programming

Object-Oriented Programming ​

Object-oriented design :

• Identify components called objects.
• Determine how objects interact with each other
• Specify relevant data and possible operations to be performed on that data.
• Each object consists of data and operations on that data.
• An object combines data and operations on the data into a single unit
• A language that supports object-oriented design is called an object-oriented programming (OOP) language
• Must learn how to represent data in computer memory, how to manipulate data, and how to implement operations.
• C++ was designed to support object-oriented programming.
• Object-oriented design is used with structured design.

Advanced Coding Interview Preparation with C++

This rigorous learning path extends your C++ programming proficiency from intermediate to advanced level. It's dedicated to refining your knowledge and application of sophisticated algorithms, complex data structures, and efficient implementation strategies.

This learning path includes:

5 courses with bite-sized lessons and practices

23 engaging lessons in text and video formats

87 hands-on practices in our state-of-the art IDE

One-on-one guidance from Cosmo, our AI tutor

Trusted by learners working at top companies

Multidimensional arrays and their traversal in c++.

Enhance your understanding of multidimensional arrays and their traversal techniques. This course will provide you with the expertise to manipulate multidimensional arrays, transpose rows and columns, and iterate over nested elements efficiently.

C++ HashMaps in Practice: Revision and Application

Strengthen your understanding and application of hashmap data structures with a focus on counting and aggregation tasks. This course will deepen your comprehension of efficient data access and manipulation using hashmaps.

Mastering Task Decomposition in C++

Learn the art of breaking down complex tasks into manageable sub-tasks. This course will help you develop skills to effectively structure, divide, and implement individual parts of sophisticated coding problems and merge them into a cohesive solution.

Mastering Algorithms: HashMaps, Two Pointers, and Beyond in C++

Dive into the key algorithms involving HashMaps, HashSets, and two-pointer techniques. This course will enhance your skills in optimizing data structures and problem-solving methods.

Maximizing Efficiency in Problem-Solving Techniques in C++

This comprehensive course covers unique problem-solving approaches and analysis techniques. Topics include optimizing brute force methods, addressing combinatorial problems, and utilizing heaps and sorted lists efficiently.

Meet Cosmo: The smartest AI guide in the universe

Our built-in AI guide and tutor, Cosmo, prompts you with challenges that are built just for you and unblocks you when you get stuck.

Whether you’re leveling up or just starting out, find your next step here.

Other paths you may like.

Mastering Algorithms and Data Structures in Python

This path will teach you some of the key foundational skills in computer programming often required in technical interviews. It will focus on understanding how to choose optimal algorithms and data structures for different problems, how to apply them, and how to explain their reasoning.

Python Programming for Beginners

Kickstart your journey as a Computer Programmer with a strong foundation in one of the most popular languages in the world - Python. This beginner-friendly path provides a comprehensive understanding of Python syntax and fundamental programming concepts, paving the way for further exploration into the vast universe of coding.

JavaScript Programming for Beginners

Embark on your adventure into the programming universe with JavaScript, one of the most widely used languages in web development. This beginner-friendly path will guide you through JavaScript syntax and fundamental programming concepts, laying the groundwork for your future exploration into the vast cosmos of coding.

• Advanced Search

A cut-and-solve algorithm for virtual machine consolidation problem

New citation alert added.

This alert has been successfully added and will be sent to:

You will be notified whenever a record that you have chosen has been cited.

To manage your alert preferences, click on the button below.

New Citation Alert!

Please log in to your account

Information & Contributors

Bibliometrics & citations, view options, recommendations, a kernel search algorithm for virtual machine consolidation problem in cloud computing.

Virtual machine consolidation refers to the process of reallocating virtual machines across a set of target servers. It can be formulated as a mixed integer linear programming problem, which is known to be NP-hard. In this paper, we propose a ...

A branch-and-cut algorithm for a class of sum-of-ratios problems

The problem of maximizing a sum of concave-convex ratios over a convex set is addressed. The projection of the problem onto the image space of the functions that describe the ratios leads to the equivalent problem of maximizing a sum of elementary ...

Exact Algorithm for Minimising the Number of Setups in the One-Dimensional Cutting Stock Problem

The cutting stock problem is that of finding a cutting of stock material to meet demands for small pieces of prescribed dimensions while minimising the amount of waste. Because changing over from one cutting pattern to another involves significant ...

Information

Published in.

Elsevier Science Publishers B. V.

Netherlands

Publication History

Author tags.

• Cut-and-solve
• Cutting plane
• Exact algorithm
• Mixed integer linear programming
• Virtual machine consolidation
• Research-article

Contributors

Other metrics, bibliometrics, article metrics.

• 0 Total Citations
• 0 Total Downloads
• Downloads (Last 12 months) 0
• Downloads (Last 6 weeks) 0

View options

Login options.

Check if you have access through your login credentials or your institution to get full access on this article.

Full Access

Share this publication link.

Copying failed.

Share on social media

Affiliations, export citations.

• Please download or close your previous search result export first before starting a new bulk export. Preview is not available. By clicking download, a status dialog will open to start the export process. The process may take a few minutes but once it finishes a file will be downloadable from your browser. You may continue to browse the DL while the export process is in progress. Download
• Download citation
• Copy citation

We are preparing your search results for download ...

We will inform you here when the file is ready.

Your file of search results citations is now ready.

Your search export query has expired. Please try again.

• Trending Now
• Foundational Courses
• Data Science
• Practice Problem
• Machine Learning
• System Design
• DevOps Tutorial

CBSE Class 11 | Problem Solving Methodologies

Problem solving process.

The process of problem-solving is an activity which has its ingredients as the specification of the program and the served dish is a correct program. This activity comprises of four steps : 1. Understanding the problem: To solve any problem it is very crucial to understand the problem first. What is the desired output of the code and how that output can be generated? The obvious and essential need to generate the output is an input. The input may be singular or it may be a set of inputs. A proper relationship between the input and output must be drawn in order to solve the problem efficiently. The input set should be complete and sufficient enough to draw the output. It means all the necessary inputs required to compute the output should be present at the time of computation. However, it should be kept in mind that the programmer should ensure that the minimum number of inputs should be there. Any irrelevant input only increases the size of and memory overhead of the program. Thus Identifying the minimum number of inputs required for output is a crucial element for understanding the problem.

2. Devising the plan: Once a problem has been understood, a proper action plan has to be devised to solve it. This is called devising the plan. This step usually involves computing the result from the given set of inputs. It uses the relationship drawn between inputs and outputs in the previous step. The complexity of this step depends upon the complexity of the problem at hand.

3. Executing the plan: Once the plan has been defined, it should follow the trajectory of action while ensuring the plan’s integrity at various checkpoints. If any inconsistency is found in between, the plan needs to be revised.

4. Evaluation: The final result so obtained must be evaluated and verified to see if the problem has been solved satisfactorily.

Problem Solving Methodology(The solution for the problem)

The methodology to solve a problem is defined as the most efficient solution to the problem. Although, there can be multiple ways to crack a nut, but a methodology is one where the nut is cracked in the shortest time and with minimum effort. Clearly, a sledgehammer can never be used to crack a nut. Under problem-solving methodology, we will see a step by step solution for a problem. These steps closely resemble the software life cycle . A software life cycle involves several stages in a program’s life cycle. These steps can be used by any tyro programmer to solve a problem in the most efficient way ever. The several steps of this cycle are as follows :

Step by step solution for a problem (Software Life Cycle) 1. Problem Definition/Specification: A computer program is basically a machine language solution to a real-life problem. Because programs are generally made to solve the pragmatic problems of the outside world. In order to solve the problem, it is very necessary to define the problem to get its proper understanding. For example, suppose we are asked to write a code for “ Compute the average of three numbers”. In this case, a proper definition of the problem will include questions like : “What exactly does average mean?” “How to calculate the average?”

Once, questions like these are raised, it helps to formulate the solution of the problem in a better way. Once a problem has been defined, the program’s specifications are then listed. Problem specifications describe what the program for the problem must do. It should definitely include :

what is the input set of the program

What is the desired output of the program and in what form the output is desired?

2. Problem Analysis (Breaking down the solution into simple steps): This step of solving the problem follows a modular approach to crack the nut. The problem is divided into subproblems so that designing a solution to these subproblems gets easier. The solutions to all these individual parts are then merged to get the final solution of the original problem. It is like divide and merge approach.

Modular Approach for Programming :

The process of breaking a large problem into subproblems and then treating these individual parts as different functions is called modular programming. Each function behaves independent of another and there is minimal inter-functional communication. There are two methods to implement modular programming :

• Top Down Design : In this method, the original problem is divided into subparts. These subparts are further divided. The chain continues till we get the very fundamental subpart of the problem which can’t be further divided. Then we draw a solution for each of these fundamental parts.
• Bottom Up Design : In this style of programming, an application is written by using the pre-existing primitives of programming language. These primitives are then amalgamated with more complicated features, till the application is written. This style is just the reverse of the top-down design style.

3. Problem Designing: The design of a problem can be represented in either of the two forms :

The ways to execute any program are of three categories:

• Sequence Statements Here, all the instructions are executed in a sequence, that is, one after the another, till the program is executed.
• Selection Statements As it is self-clear from the name, in these type of statements the whole set of instructions is not executed. A selection has to be made. A selected number of instructions are executed based on some condition. If the condition holds true then some part of the instruction set is executed, otherwise, another part of the set is executed. Since this selection out of the instruction set has to be made, thus these type of instructions are called Selection Statements.

Identification of arithmetic and logical operations required for the solution : While writing the algorithm for a problem, the arithmetic and logical operations required for the solution are also usually identified. They help to write the code in an easier manner because the proper ordering of the arithmetic and logical symbols is necessary to determine the correct output. And when all this has been done in the algorithm writing step, it just makes the coding task a smoother one.

• Flow Chart : Flow charts are diagrammatic representation of the algorithm. It uses some symbols to illustrate the starting and ending of a program along with the flow of instructions involved in the program.

4. Coding: Once an algorithm is formed, it can’t be executed on the computer. Thus in this step, this algorithm has to be translated into the syntax of a particular programming language. This process is often termed as ‘coding’. Coding is one of the most important steps of the software life cycle. It is not only challenging to find a solution to a problem but to write optimized code for a solution is far more challenging.

Writing code for optimizing execution time and memory storage : A programmer writes code on his local computer. Now, suppose he writes a code which takes 5 hours to get executed. Now, this 5 hours of time is actually the idle time for the programmer. Not only it takes longer time, but it also uses the resources during that time. One of the most precious computing resources is memory. A large program is expected to utilize more memory. However, memory utilization is not a fault, but if a program is utilizing unnecessary time or memory, then it is a fault of coding. The optimized code can save both time and memory. For example, as has been discussed earlier, by using the minimum number of inputs to compute the output , one can save unnecessary memory utilization. All such techniques are very necessary to be deployed to write optimized code. The pragmatic world gives reverence not only to the solution of the problem but to the optimized solution. This art of writing the optimized code also called ‘competitive programming’.

5. Program Testing and Debugging: Program testing involves running each and every instruction of the code and check the validity of the output by a sample input. By testing a program one can also check if there’s an error in the program. If an error is detected, then program debugging is done. It is a process to locate the instruction which is causing an error in the program and then rectifying it. There are different types of error in a program : (i) Syntax Error Every programming language has its own set of rules and constructs which need to be followed to form a valid program in that particular language. If at any place in the entire code, this set of rule is violated, it results in a syntax error. Take an example in C Language

In the above program, the syntax error is in the first printf statement since the printf statement doesn’t end with a ‘;’. Now, until and unless this error is not rectified, the program will not get executed.

Once the error is rectified, one gets the desired output. Suppose the input is ‘good’ then the output is : Output:

(ii) Logical Error An error caused due to the implementation of a wrong logic in the program is called logical error. They are usually detected during the runtime. Take an example in C Language:

In the above code, the ‘for’ loop won’t get executed since n has been initialized with the value of 11 while ‘for’ loop can only print values smaller than or equal to 10. Such a code will result in incorrect output and thus errors like these are called logical errors. Once the error is rectified, one gets the desired output. Suppose n is initialised with the value ‘5’ then the output is : Output:

(iii) Runtime Error Any error which causes the unusual termination of the program is called runtime error. They are detected at the run time. Some common examples of runtime errors are : Example 1 :

If during the runtime, the user gives the input value for B as 0 then the program terminates abruptly resulting in a runtime error. The output thus appears is : Output:

Example 2 : If while executing a program, one attempts for opening an unexisting file, that is, a file which is not present in the hard disk, it also results in a runtime error.

6. Documentation : The program documentation involves :

• Problem Definition
• Problem Design
• Documentation of test perform
• History of program development

7. Program Maintenance: Once a program has been formed, to ensure its longevity, maintenance is a must. The maintenance of a program has its own costs associated with it, which may also exceed the development cost of the program in some cases. The maintenance of a program involves the following :

• Detection and Elimination of undetected errors in the existing program.
• Modification of current program to enhance its performance and adaptability.
• Enhancement of user interface
• Enriching the program with new capabilities.
• Updation of the documentation.

Control Structure- Conditional control and looping (finite and infinite)

There are codes which usually involve looping statements. Looping statements are statements in which instruction or a set of instructions is executed multiple times until a particular condition is satisfied. The while loop, for loop, do while loop, etc. form the basis of such looping structure. These statements are also called control structure because they determine or control the flow of instructions in a program. These looping structures are of two kinds :

In the above program, the ‘for’ loop gets executed only until the value of i is less than or equal to 10. As soon as the value of i becomes greater than 10, the while loop is terminated. Output:

In the above code, one can easily see that the value of n is not getting incremented. In such a case, the value of n will always remain 1 and hence the while loop will never get executed. Such loop is called an infinite loop. Output:

Please Login to comment...

Similar reads.

• School Programming

Improve your Coding Skills with Practice

What kind of Experience do you want to share?

Information

• Author Services

Initiatives

You are accessing a machine-readable page. In order to be human-readable, please install an RSS reader.

All articles published by MDPI are made immediately available worldwide under an open access license. No special permission is required to reuse all or part of the article published by MDPI, including figures and tables. For articles published under an open access Creative Common CC BY license, any part of the article may be reused without permission provided that the original article is clearly cited. For more information, please refer to https://www.mdpi.com/openaccess .

Feature papers represent the most advanced research with significant potential for high impact in the field. A Feature Paper should be a substantial original Article that involves several techniques or approaches, provides an outlook for future research directions and describes possible research applications.

Feature papers are submitted upon individual invitation or recommendation by the scientific editors and must receive positive feedback from the reviewers.

Editor’s Choice articles are based on recommendations by the scientific editors of MDPI journals from around the world. Editors select a small number of articles recently published in the journal that they believe will be particularly interesting to readers, or important in the respective research area. The aim is to provide a snapshot of some of the most exciting work published in the various research areas of the journal.

Original Submission Date Received: .

• Active Journals
• Find a Journal
• Proceedings Series
• For Authors
• For Reviewers
• For Editors
• For Librarians
• For Publishers
• For Societies
• For Conference Organizers
• Open Access Policy
• Institutional Open Access Program
• Special Issues Guidelines
• Editorial Process
• Research and Publication Ethics
• Article Processing Charges
• Testimonials
• Preprints.org
• SciProfiles
• Encyclopedia

Article Menu

• Subscribe SciFeed
• Recommended Articles
• Google Scholar
• on Google Scholar
• Table of Contents

Find support for a specific problem in the support section of our website.

Please let us know what you think of our products and services.

Visit our dedicated information section to learn more about MDPI.

JSmol Viewer

Knowledge-guided parallel hybrid local search algorithm for solving time-dependent agile satellite scheduling problems.

Share and Cite

Shan, Y.; Wang, X.; Cheng, S.; Zhang, M.; Xing, L. Knowledge-Guided Parallel Hybrid Local Search Algorithm for Solving Time-Dependent Agile Satellite Scheduling Problems. Symmetry 2024 , 16 , 813. https://doi.org/10.3390/sym16070813

Shan Y, Wang X, Cheng S, Zhang M, Xing L. Knowledge-Guided Parallel Hybrid Local Search Algorithm for Solving Time-Dependent Agile Satellite Scheduling Problems. Symmetry . 2024; 16(7):813. https://doi.org/10.3390/sym16070813

Shan, Yuyuan, Xueping Wang, Shi Cheng, Mingming Zhang, and Lining Xing. 2024. "Knowledge-Guided Parallel Hybrid Local Search Algorithm for Solving Time-Dependent Agile Satellite Scheduling Problems" Symmetry 16, no. 7: 813. https://doi.org/10.3390/sym16070813

Article Metrics

Article access statistics, further information, mdpi initiatives, follow mdpi.

Subscribe to receive issue release notifications and newsletters from MDPI journals

Help | Advanced Search

Quantum Physics

Title: a catalyst framework for the quantum linear system problem via the proximal point algorithm.

Abstract: Solving systems of linear equations is a fundamental problem, but it can be computationally intensive for classical algorithms in high dimensions. Existing quantum algorithms can achieve exponential speedups for the quantum linear system problem (QLSP) in terms of the problem dimension, but even such a theoretical advantage is bottlenecked by the condition number of the coefficient matrix. In this work, we propose a new quantum algorithm for QLSP inspired by the classical proximal point algorithm (PPA). Our proposed method can be viewed as a meta-algorithm that allows inverting a modified matrix via an existing \texttt{QLSP\_solver}, thereby directly approximating the solution vector instead of approximating the inverse of the coefficient matrix. By carefully choosing the step size $\eta$, the proposed algorithm can effectively precondition the linear system to mitigate the dependence on condition numbers that hindered the applicability of previous approaches.

Submission history

Access paper:.

• HTML (experimental)
• Other Formats

References & Citations

• INSPIRE HEP
• Google Scholar
• Semantic Scholar

BibTeX formatted citation

Bibliographic and Citation Tools

Code, data and media associated with this article, recommenders and search tools.

• Institution

arXivLabs: experimental projects with community collaborators

arXivLabs is a framework that allows collaborators to develop and share new arXiv features directly on our website.

Both individuals and organizations that work with arXivLabs have embraced and accepted our values of openness, community, excellence, and user data privacy. arXiv is committed to these values and only works with partners that adhere to them.

Have an idea for a project that will add value for arXiv's community? Learn more about arXivLabs .

On the Immersed Boundary Method with Time-Filter-SAV for Solving Fluid–Structure Interaction Problem

• Published: 27 June 2024
• Volume 100 , article number  45 , ( 2024 )

Cite this article

• Qixing Chen 1 ,
• Li Cai   ORCID: orcid.org/0000-0002-2031-2015 1 ,
• Feifei Jing   ORCID: orcid.org/0000-0002-7811-1443 1 ,
• Pengfei Ma 1 ,
• Xiaoyu Luo 2 &
• Hao Gao 2  

10 Accesses

Explore all metrics

In this work, the immersed boundary method with time filter and scalar auxiliary variable techniques is studied to solve the fluid–structure interaction problems. For the fluid flow, we first use the backward Euler differentiation formula in temporal discretization, we then employ the time filter technique to improve its convergence order, the scalar auxiliary variable strategy is visited to decouple the fluid equations and achieve fast solutions. We adopt the immersed boundary method to build the connection between the fluid and the structure, as well as characterize the deformations of the structure. We approximate the fluid–structure interaction model by the finite element method in space. The semi-discrete and fully-discrete implicit numerical schemes are proposed followed with unconditionally stability properties. We carry out several numerical experiments to validate the convergence behaviors and efficiency of the algorithms.

This is a preview of subscription content, log in via an institution to check access.

Access this article

Price includes VAT (Russian Federation)

Instant access to the full article PDF.

Rent this article via DeepDyve

Institutional subscriptions

Similar content being viewed by others

An improved immersed boundary method by coupling of the multi-direct forcing and Fourier pseudo-spectral methods

Improved Implicit Immersed Boundary Method via Operator Splitting

A Velocity Decomposition Approach for Solving the Immersed Interface Problem with Dirichlet Boundary Conditions

Data availability.

The datasets generated during and analyzed during the current study are available from the corresponding author on reasonable request.

Alnaes, M.S., Blechta, J., Hake, J., Johansson, A., Kehlet, B., Logg, A., Richardson, C. Ring, J., Rognes, M.E., Wells, G.N.: The FEniCS Project Version 1.5, Archive of Numerical Software, 3 (2015)

Boffi, D., Cavallini, N., Gastaldi, L.: The finite element immersed boundary method with distributed Lagrange multiplier. SIAM J. Numer. Anal. 53 (6), 2584–2604 (2015)

Article   MathSciNet   Google Scholar  

Boffi, D., Gastaldi, L.: A finite element approach for the immersed boundary method. Comput. Struct. 81 (8–11), 491–501 (2003)

Boffi, D., Gastaldi, L.: A fictitious domain approach with Lagrange multiplier for fluid-structure interactions. Numer. Math. 135 (3), 711–732 (2017)

Boffi, D., Gastaldi, L.: Discrete models for fluid-structure interactions: the finite element immersed boundary method. Discrete Contin. Dyn. Syst. Ser. S 9 (1), 89–107 (2016)

MathSciNet   Google Scholar  

Boffi, D., Gastaldi, L.: Existence, uniqueness, and approximation of a fictitious domain formulation for fluid-structure interactions, Atti Accad. Naz. Lincei Rend. Lincei Mat. Appl. 33 (1), 109–137 (2022)

Boffi, D., Gastaldi, L., Heltai, L.: Stability results and algorithmic strategies for the finite element approach to the immersed boundary method, in: Bermudez de Castro, A., Gomez, D., Quintela, P., Salgado, P. (Eds.), Proceedings of ENUMATH 2005 the European Conference on Numerical Mathematics and Advanced Applications, (2006) 557-566

Boffi, D., Gastaldi, L., Heltai, L.: Numerical stability of the finite element immersed boundary method. Math. Models Methods Appl. Sci. 17 (10), 1479–1505 (2007)

Boffi, D., Gastaldi, L., Heltai, L.: On the CFL condition for the finite element immersed boundary method. Comput. Struct. 85 (11–14), 775–783 (2007)

Boffi, D., Gastaldi, L., Heltai, L., Peskin, C.S.: On the hyper-elastic formulation of the immersed boundary method. Comput. Meth. Appl. Mech. Engrg. 197 (25–28), 2210–2231 (2008)

Borazjani, I., Ge, L., Sotiropoulos, F.: High-resolution fluid-structure interaction simulations of flow through a bi-leaflet mechanical heart valve in an anatomic aorta. Annu. Biomed. Engrg. 38 (2), 326–344 (2010)

Article   Google Scholar  

Bratanow, T.: Finite element approximations of the Navier-Stokes equations. Appl. Math. Model. 5 (3), 212–213 (1981)

DeCaria, V., Gottlieb, S., Grant, Z.J., Layton, W.J.: A general linear method approach to the design and optimization of efficient, accurate, and easily implemented time-stepping methods in CFD. J. Comput. Phys. 455 , 110927 (2022)

DeCaria, V., Guzel, A., Layton, W., Li, Y.: A variable stepsize, variable order family of low complexity. SIAM J. Sci. Comput. 43 (3), A2130–A2160 (2021)

DeCaria, V., Layton, W., McLaughlin, M.: A conservative, second order, unconditionally stable artificial compression method. Comput. Methods Appl. Mech. Engrg. 325 , 733–747 (2017)

DeCaria, V., Layton, W., McLaughlin, M.: An analysis of the Robert-Asselin time filter for the correction of nonphysical acoustics in an artificial compression method. Numer. Methods Partial Differ. Equ. 35 (3), 916–935 (2019)

DeCaria, V., Layton, W., Zhao, H.: A time-accurate, adaptive discretization for fluid flow problems. Int. J. Numer. Anal. Model. 17 (2), 254–280 (2020)

DeCaria, V., Schneier, M.: An embedded variable step IMEX scheme for the incompressible Navier-Stokes equations. Comput. Methods Appl. Mech. Engrg. 376 , 113661 (2021)

Devendran, D., Peksin, C.S.: An energy-based immersed boundary method for incompressible viscoelasticity. J. Comput. Phys. 231 (14), 4613–4642 (2012)

Girault, V., Raviar, P.A.: Finite Element Methods for Navier-Stokes Equations. Theory and Algorithms. Springer-Verlag, Berlin (1986)

Book   Google Scholar  

Glowinski, R.: Finite element methods for incompressible viscous flow. Handb. Numer. Anal. 9 , 3–1176 (2003)

Griffith, B.E., Luo, X.Y.: Hybrid Finite difference/finite element immersed boundary method. Int. J. Numer. Methods Biomed. Engrg. 33 (12), e2888 (2017)

Griffith, B.E., Luo, X.Y., McQueen, D.M., Peskin, C.S.: Simulating the fluid dynamics of natural and prosthetic heart valves using the immersed boundary method. Int. J. Appl. Mech. 1 (1), 137–177 (2009)

Guidoboni, G., Glowinski, R., Cavallini, N., Canic, S.: Stable loosely-coupled-type algorithm for fluid-structure interaction in blood flow. J. Comput. Phys. 228 (18), 6916–6937 (2009)

Guzel, A.B., Layton, W.J.: Time filters increase accuracy of the fully implicit method. BIT Numer. Math. 58 , 301–315 (2018)

Heltai, L., Costanzo, F.: Variational implementation of immersed finite element methods. Comput. Meth. Appl. Mech. Engrg. 229 , 110–127 (2012)

Heywood, J.G., Rannacher, R.: Finite-element approximations of the nonstationary Navier-Stokes problem. Part IV: error estimates for second-order time discretization. SIAM J. Numer. Anal. 27 (2), 353–384 (1990)

Jain, A., Jones, N.: Coupled flutter and buffeting analysis of long-span bridges. J. Struct. Engrg. 122 (7), 716–725 (1996)

Jones, S.K., Laurenza, R., Hedrick, T.L., Griffith, B.E., Miller, L.A.: Lift vs. drag based mechanisms for vertical force production in the smallest flying insects. J. Theor. Biol. 384 , 105–120 (2015)

Knoll, D., Keyes, D.: Jacobian-free Newton-Krylov methods: a survey of approaches and applications. J. Comput. Phys. 193 , 357–397 (2004)

Layton, W., Li, Y., Trenchea, C.: Recent developments in IMEX methods with time filters for systems of evolution equations. J. Comput. Appl. Math. 299 , 50–67 (2016)

Lemmon, J.D., Yoganathan, A.P.: Three-dimensional computational model of left heart diastolic function with fluid-structure interaction. J. Biomech. Engrg. 122 (2), 109–117 (2000)

Lemmon, J.D., Yoganathan, A.P.: Computational modeling of left heart diastolic function: examination of ventricular dysfunction. J. Biomech. Engrg. 122 (4), 297–303 (2000)

Li, X.L., Shen, J.: Error analysis of the SAV-MAC scheme for the Navier-Stokes equations. SIAM J. Numer. Anal. 58 (5), 2465–2491 (2020)

Li, X.L., Shen, J., Liu, Z.G.: New SAV-pressure correction methods for the Navier-Stokes equations: stability and error analysis. Math. Comput. 91 (333), 141–167 (2021)

Li, N., Wu, J.L., Feng, X.L.: Filtered time-stepping method for incompressible Navier-Stokes equations with variable density. J. Comput. Phys. 473 , 111764 (2023)

Lin, L., Yang, Z., Dong, S.: Numerical approximation of incompressible Navier-Stokes equations based on an auxiliary energy variable. J. Comput. Phys. 388 , 1–22 (2019)

Logg, A., Mardal, K.A., Wells, G.N.: Automated Solution of Differential Equations by the Finite Element Method. The FEniCS Book, Springer, Berlin, Heidelberg (2012)

McQueen, D.M., Peskin, C.S.: Shared-memory parallel vector implementation of the immersed boundary method for the computation of blood flow in the beating mammalian heart. J. Supercomput. 11 (3), 213–236 (1997)

McQueen, D.M., Peskin, C.S.: A three-dimensional computer model of the human heart for studying cardiac fluid dynamics. Comput. Graph. 34 (1), 56–60 (2000)

Miller, L.A., Peskin, C.S.: When vortices stick: an aerodynamic transition in tiny insect flight. J. Exp. Biol. 207 (17), 3073–3088 (2004)

Miller, L.A., Peskin, C.S.: Flexible clap and fling in tiny insect flight. J. Exp. Biol. 212 (19), 3076–3090 (2009)

Peskin, C.S.: Flow patterns around heart valves: a numerical method. J. Comput. Phys. 10 (2), 252–271 (1972)

Peskin, C.S.: Numerical analysis of blood flow in the heart. J. Comput. Phys. 25 (3), 220–252 (1977)

Peskin, C.S.: The immersed boundary method. Acta Numer 11 , 479–517 (2002)

Qin, Y., Wang, Y.S., Li, J.: A variable time step time filter algorithm for the geothermal system. SIAM J. Numer. Anal. 60 (5), 2781–2806 (2022)

Quarteroni, A., Formaggia, L.: Mathematical Modelling and Numerical Simulation of the Cardiovascular System, Handbook of Numerical. Analysis 12 , 3–127 (2004)

Google Scholar  

Quarteroni, A., Manzoni, A., Vergara, C.: The cardiovascular system: mathematical modelling, numerical algorithms and clinical applications. Acta Numer. 26 , 365–590 (2017)

Shen, J.: On error estimates of the projection methods for the Navier-Stokes equations: second-order schemes. Math. Comput. 65 (215), 1039–1066 (1996)

Shen, J., Xu, J., Yang, J.: The scalar auxiliary variable (SAV) approach for gradient flows. J. Comput. Phys. 353 , 407–416 (2018)

Shen, J., Xu, J., Yang, J.: A new class of efficient and robust energy stable schemes for gradient flows. SIAM Rev. 61 (3), 474–506 (2019)

Sotiropoulos, F., Borazjani, I.: A review of state-of-the-art numerical methods for simulating flow through mechanical heart valves. Med. Biol. Engrg. Comput. 47 (3), 245–256 (2009)

Stockie, J.M., Wetton, B.R.: Analysis of stiffness in the immersed boundary method and implications for time-stepping schemes. J. Comput. Phys. 154 (1), 41–64 (1999)

Stockie, J.M., Wetton, B.T.R.: Stability analysis for the immersed fiber problem. SIAM J. Appl. Math. 55 (6), 1577–1591 (1995)

Suli, E.: Convergence and nonlinear stability of the Lagrange-Galerkin method for the Navier-Stokes equations. Numer. Math. 53 (4), 459–483 (1988)

Temam, R.: Navier-Stokes Equations: Theory and Numerical Analysis, AMS Chelsea Publishing, (2001)

Tian, F.B., Luo, H., Zhu, L., Liao, J.C., Lu, X.Y.: An efficient immersed boundary-lattice Boltzmann method for the hydrodynamic interaction of elastic filaments. J. Comput. Phys. 230 (19), 7266–7283 (2011)

Tu, C., Peskin, C.S.: Stability and instability in the computation of flows with moving immersed boundaries: a comparison of three methods. SIAM J. Sci. Stat. Comput. 13 (6), 1361–1376 (2004)

Wang, X., Wang, C., Zhang, L.T.: Semi-implicit formulation of the immersed finite element method. Comput. Mech. 49 (4), 421–430 (2012)

Wang, X., Zhang, L.T.: Interpolation functions in the immersed boundary and finite element methods. Comput. Mech. 45 (4), 321–334 (2010)

Yagawa, G., Eguchi, Y.: Finite element methods for incompressible viscous flow. JSME Int. J. 30 (265), 1009–1017 (2008)

Yang, J., Agrawal, A., Samali, B.: Benchmark problem for response control of wind-excited tall buildings. J. Engrg. Mech. 130 (4), 437–446 (2004)

Zeng, Y., Huang, P., He, Y.: A time filter method for solving the double-diffusive natural convection model. Comput. Fluids 235 , 105265 (2022)

Zhang, L.T., Gay, M.: Immersed finite element method for fluid-structure interactions. J. Fluid. Struct. 23 (6), 839–857 (2007)

Zhao, H., Freund, J.B., Moser, R.D.: A fixed-mesh method for incompressible flow-structure systems with finite solid deformations. J. Comput. Phys. 227 (6), 3114–3140 (2008)

Download references

This work is supported by National Natural Science Foundation of China (Grant Nos. 12271440, 12371407) and the Fundamental Research Funds for the Central Universities of ChinaGrant No. D5000230046.

Author information

Authors and affiliations.

School of Mathematics and Statistics, Northwestern Polytechnical University, Xi’an, 710049, People’s Republic of China

Qixing Chen, Li Cai, Feifei Jing & Pengfei Ma

School of Mathematics and Statistics, University of Glasgow, Glasgow, G12 8QQ, UK

Xiaoyu Luo & Hao Gao

You can also search for this author in PubMed   Google Scholar

Corresponding authors

Correspondence to Li Cai or Feifei Jing .

Ethics declarations

Conflict of interest.

The authors have not disclosed any conflict of interest.

Additional information

Publisher's note.

Springer Nature remains neutral with regard to jurisdictional claims in published maps and institutional affiliations.

This work is supported by National Natural Science Foundation of China (Grant Nos. 12271440, 12371407) and the Fundamental Research Funds for the Central Universities of China–Grant No. D5000230046.

Rights and permissions

Springer Nature or its licensor (e.g. a society or other partner) holds exclusive rights to this article under a publishing agreement with the author(s) or other rightsholder(s); author self-archiving of the accepted manuscript version of this article is solely governed by the terms of such publishing agreement and applicable law.

Reprints and permissions

About this article

Chen, Q., Cai, L., Jing, F. et al. On the Immersed Boundary Method with Time-Filter-SAV for Solving Fluid–Structure Interaction Problem. J Sci Comput 100 , 45 (2024). https://doi.org/10.1007/s10915-024-02591-5

Download citation

Received : 22 April 2024

Revised : 07 June 2024

Accepted : 11 June 2024

Published : 27 June 2024

DOI : https://doi.org/10.1007/s10915-024-02591-5

Share this article

Anyone you share the following link with will be able to read this content:

Sorry, a shareable link is not currently available for this article.

Provided by the Springer Nature SharedIt content-sharing initiative

• Fluid–structure interaction problem
• Immersed boundary method
• Time filter
• Scalar auxiliary variable
• Find a journal
• Publish with us
• Track your research