problem solving and algorithmic

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.

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

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.

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.

Apply now and work for two to five years. We'll save you a seat in our MBA class when you're ready to come back to campus for your degree.

Executive Programs

The 20-month program teaches the science of management to mid-career leaders who want to move from success to significance.

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

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

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

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

5 new cybersecurity regulations to know about

MIT Sloan’s new courses focus on AI, analytics, climate

GDPR reduced firms’ data and computation use

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.

A person holds up a lightbulb covered in AI data imagery

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.

Three Elegant Algorithms Every Computer Science Beginner Should Know

Have a language expert improve your writing

Check your paper for plagiarism in 10 minutes, generate your apa citations for free.

Knowledge Base
Using AI tools
What Is an Algorithm? | Definition & Examples

What Is an Algorithm? | Definition & Examples

Published on August 9, 2023 by Kassiani Nikolopoulou . Revised on August 29, 2023.

An algorithm is a set of steps for accomplishing a task or solving a problem. Typically, algorithms are executed by computers, but we also rely on algorithms in our daily lives. Each time we follow a particular step-by-step process, like making coffee in the morning or tying our shoelaces, we are in fact following an algorithm.

In the context of computer science , an algorithm is a mathematical process for solving a problem using a finite number of steps. Algorithms are a key component of any computer program and are the driving force behind various systems and applications, such as navigation systems, search engines, and music streaming services.

Instantly correct all language mistakes in your text

Upload your document to correct all your mistakes in minutes

What is an algorithm, how do algorithms work, examples of algorithms, other interesting articles, frequently asked questions about algorithms.

An algorithm is a sequence of instructions that a computer must perform to solve a well-defined problem. It essentially defines what the computer needs to do and how to do it. Algorithms can instruct a computer how to perform a calculation, process data, or make a decision.

The best way to understand an algorithm is to think of it as a recipe that guides you through a series of well-defined actions to achieve a specific goal. Just like a recipe produces a replicable result, algorithms ensure consistent and reliable outcomes for a wide range of tasks in the digital realm.

And just like there are numerous ways to make, for example, chocolate chip cookies by following different steps or using slightly different ingredients, different algorithms can be designed to solve the same problem, with each taking a distinct approach but achieving the same result.

Algorithms are virtually everywhere around us. Examples include the following:

Search engines rely on algorithms to find and present relevant results as quickly as possible
Social media platforms use algorithms to prioritize the content that we see in our feeds, taking into account factors like our past behavior, the popularity of posts, and relevance.
With the help of algorithms, navigation apps determine the most efficient route for us to reach our destination.
It must be correct . In other words, it should take a given problem and provide the right answer or result, even if it stops working due to an error.
It must consist of clear, practical steps that can be completed in a limited time, whether by a person or the machine that must execute the algorithm. For example, the instructions in a cookie recipe might be considered sufficiently concrete for a human cook, but they would not be specific enough for programming an automated cookie-making machine.
There should be no confusion about which step comes next , even if choices must be made (e.g., when using “if” statements).
It must have a set number of steps (not an infinite number) that can be managed using loops (statements describing repeated actions or iterations).
It must eventually reach an endpoint and not get stuck in a never-ending loop.

Don't submit your assignments before you do this

The academic proofreading tool has been trained on 1000s of academic texts. Making it the most accurate and reliable proofreading tool for students. Free citation check included.

Try for free

Algorithms use a set of initial data or input , process it through a series of logical steps or rules, and produce the output (i.e., the outcome, decision, or result).

If you want to make chocolate chip cookies, for instance, the input would be the ingredients and quantities, the process would be the recipe you choose to follow, and the output would be the cookies.

Algorithms are eventually expressed in a programming language that a computer can process. However, when an algorithm is being created, it will be people, not a computer, who will need to understand it. For this reason, as a first step, algorithms are written as plain instructions.

Input: the input data is a single-digit number (e.g., 5).
Transformation/processing: the algorithm takes the input (number 5) and performs the specific operation (i.e., multiplies the number by itself).
Output: the result of the calculation is the square of the input number, which, in this case, would be 25 (since 5 * 5 = 25).

We could express this as an algorithm in the following way:

Algorithm: Calculate the square of a number

Input the number (N) whose square you want to find.
Multiply the number (N) by itself.
Store the result of the multiplication in a variable (result).
Output the value of the variable (result), which represents the square of the input number.

It is important to keep in mind that an algorithm is not the same as a program or code. It is the logic or plan for solving a problem represented as a simple step-by-step description. Code is the implementation of the algorithm in a specific programming language (like C++ or Python), while a program is an implementation of code that instructs a computer on how to execute an algorithm and perform a task.

Instead of telling a computer exactly what to do, some algorithms allow computers to learn on their own and improve their performance on a specific task. These machine learning algorithms use data to identify patterns and make predictions or conduct data mining to uncover hidden insights in data that can inform business decisions.

Broadly speaking, there are three different types of algorithms:

Linear sequence algorithms follow a specific set or steps, one after the other. Just like following a recipe, each step depends on the success of the previous one.
For example, in the context of a cookie recipe, you would include the step “if the dough is too sticky, you might need to refrigerate it.”
For example, a looping algorithm could be used to handle the process of making multiple cookies from a single batch of dough. The algorithm would repeat a specific set of instructions to form and bake cookies until all the dough has been used.

Algorithms are fundamental tools for problem-solving in both the digital world and many real-life scenarios. Each time we try to solve a problem by breaking it down into smaller, manageable steps, we are in fact using algorithmic thinking.

Identify which clothes are clean.
Consider the weather forecast for the day.
Consider the occasion for which you are getting dressed (e.g., work or school etc.).
Consider personal preferences (e.g., style or which items match).

In mathematics, algorithms are standard methods for performing calculations or solving equations because they are efficient, reliable, and applicable to various situations.

Suppose you want to add the numbers 345 and 278. You would follow a set of steps (i.e., the standard algorithm for addition):

Write down the numbers so the digits align.
Start from the rightmost digits (the ones place) and add them together: 5 + 8 = 13. Write down the 3 and carry over the 1 to the next column.
Move to the next column (the tens place) and add the digits along with the carried-over value: 4 + 7 + 1 = 12. Write down the 2 and carry over the 1 to the next column.
Move to the leftmost column (the hundreds place) and add the digits along with the carried-over value: 3 + 2 + 1 = 6. Write down the 6.

The final result is 623

Navigation systems are another example of the use of algorithms. Such systems use algorithms to help you find the easiest and fastest route to your destination while avoiding traffic jams and roadblocks.

If you want to know more about ChatGPT, AI tools , fallacies , and research bias , make sure to check out some of our other articles with explanations and examples.

ChatGPT vs human editor
ChatGPT citations
Is ChatGPT trustworthy?
Using ChatGPT for your studies
Sunk cost fallacy
Straw man fallacy
Slippery slope fallacy
Red herring fallacy
Ecological fallacy
Logical fallacy

Research bias

Implicit bias
Framing bias
Cognitive bias
Optimism bias
Hawthorne effect
Unconscious bias

In computer science, an algorithm is a list of unambiguous instructions that specify successive steps to solve a problem or perform a task. Algorithms help computers execute tasks like playing games or sorting a list of numbers. In other words, computers use algorithms to understand what to do and give you the result you need.

Algorithms and artificial intelligence (AI) are not the same, however they are closely related.

Artificial intelligence is a broad term describing computer systems performing tasks usually associated with human intelligence like decision-making, pattern recognition, or learning from experience.
Algorithms are the instructions that AI uses to carry out these tasks, therefore we could say that algorithms are the building blocks of AI—even though AI involves more advanced capabilities beyond just following instructions.

Algorithms and computer programs are sometimes used interchangeably, but they refer to two distinct but interrelated concepts.

An algorithm is a step-by-step instruction for solving a problem that is precise yet general.
Computer programs are specific implementations of an algorithm in a specific programming language. In other words, the algorithm is the high-level description of an idea, while the program is the actual implementation of that idea.

Algorithms are valuable to us because they:

Form the basis of much of the technology we use in our daily lives, from mobile apps to search engines.
Power innovations in various industries that augment our abilities (e.g., AI assistants or medical diagnosis).
Help analyze large volumes of data, discover patterns and make informed decisions in a fast and efficient way, at a scale humans are simply not able to do.
Automate processes. By streamlining tasks, algorithms increase efficiency, reduce errors, and save valuable time.

Cite this Scribbr article

If you want to cite this source, you can copy and paste the citation or click the “Cite this Scribbr article” button to automatically add the citation to our free Citation Generator.

Nikolopoulou, K. (2023, August 29). What Is an Algorithm? | Definition & Examples. Scribbr. Retrieved September 16, 2024, from https://www.scribbr.com/ai-tools/what-is-an-algorithm/

Is this article helpful?

Kassiani Nikolopoulou

Other students also liked, what is deep learning | a beginner's guide, what is data mining | definition & techniques, what is machine learning | a beginner's guide, "i thought ai proofreading was useless but..".

I've been using Scribbr for years now and I know it's a service that won't disappoint. It does a good job spotting mistakes”

What is Problem Solving Algorithm?, Steps, Representation

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, 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

[su_quote cite=””]Algorithms are the solutions to computational problems. They define a method that uses the input to a problem in order to produce the correct output. A computational problem can have many solutions.[/su_quote]

[su_quote cite=””]Algorithms have a definite beginning and a definite end, and a finite number of steps. A good algorithm, which is precise, unique and finite, receives input and produces an output.[/su_quote]

Steps for Problem Solving

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.

Analysing the Problem

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.

Developing an Algorithm

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.

Testing and Debugging

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.

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.

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 .

Advantages of Flowcharts:

Differences between algorithm and flowchart.


1	A method of representing the step-by-step logical procedure for solving a problem.	Flowchart is diagrammatic representation of an algorithm. It is constructed using different types of boxes and symbols.
2	It contains step-by-step English descriptions, each step representing a particular operation leading to solution of problem.	The flowchart employs a series of blocks and arrows, each of which represents a particular step in an algorithm.
3	These are particularly useful for small problems.	These are useful for detailed representations of complicated programs.
4	For complex programs, algorithms prove to be Inadequate.	For complex programs, Flowcharts prove to be adequate.

Pseudo code

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

You might also like, advantages and disadvantages of flowcharts, what is computer system definition, characteristics, functional units, components, generations of computer first to fifth, classification, characteristics, features, examples, what is cloud computing classification, characteristics, principles, types of cloud providers, advantages and disadvantages of operating system, types of storage devices, advantages, examples, what is c++ programming language c++ character set, c++ tokens, what are decision making statements in c types, what are operators in c different types of operators in c, data representation in computer: number systems, characters, audio, image and video, 10 evolution of computing machine, history, data and information: definition, characteristics, types, channels, approaches, what are functions of operating system 6 functions, what is artificial intelligence functions, 6 benefits, applications of ai, types of computer memory, characteristics, primary memory, secondary memory, what is debugging types of errors, what are data types in c++ types, what is operating system functions, types, types of user interface, what are expressions in c types, what is microprocessor evolution of microprocessor, types, features, leave a reply cancel reply.

Chapter: Introduction to the Design and Analysis of Algorithms

Fundamentals of Algorithmic Problem Solving

Let us start by reiterating an important point made in the introduction to this chapter:

We can consider algorithms to be procedural solutions to problems.

These solutions are not answers but specific instructions for getting answers. It is this emphasis on precisely defined constructive procedures that makes computer science distinct from other disciplines. In particular, this distinguishes it from the-oretical mathematics, whose practitioners are typically satisfied with just proving the existence of a solution to a problem and, possibly, investigating the solution’s properties.

We now list and briefly discuss a sequence of steps one typically goes through in designing and analyzing an algorithm (Figure 1.2).

Understanding the Problem

From a practical perspective, the first thing you need to do before designing an algorithm is to understand completely the problem given. Read the problem’s description carefully and ask questions if you have any doubts about the problem, do a few small examples by hand, think about special cases, and ask questions again if needed.

There are a few types of problems that arise in computing applications quite often. We review them in the next section. If the problem in question is one of them, you might be able to use a known algorithm for solving it. Of course, it helps to understand how such an algorithm works and to know its strengths and weaknesses, especially if you have to choose among several available algorithms. But often you will not find a readily available algorithm and will have to design your own. The sequence of steps outlined in this section should help you in this exciting but not always easy task.

An input to an algorithm specifies an instance of the problem the algorithm solves. It is very important to specify exactly the set of instances the algorithm needs to handle. (As an example, recall the variations in the set of instances for the three greatest common divisor algorithms discussed in the previous section.) If you fail to do this, your algorithm may work correctly for a majority of inputs but crash on some “boundary” value. Remember that a correct algorithm is not one that works most of the time, but one that works correctly for all legitimate inputs.

Do not skimp on this first step of the algorithmic problem-solving process; otherwise, you will run the risk of unnecessary rework.

Ascertaining the Capabilities of the Computational Device

Once you completely understand a problem, you need to ascertain the capabilities of the computational device the algorithm is intended for. The vast majority of

algorithms in use today are still destined to be programmed for a computer closely resembling the von Neumann machine—a computer architecture outlined by the prominent Hungarian-American mathematician John von Neumann (1903– 1957), in collaboration with A. Burks and H. Goldstine, in 1946. The essence of this architecture is captured by the so-called random-access machine ( RAM ). Its central assumption is that instructions are executed one after another, one operation at a time. Accordingly, algorithms designed to be executed on such machines are called sequential algorithms .

The central assumption of the RAM model does not hold for some newer computers that can execute operations concurrently, i.e., in parallel. Algorithms that take advantage of this capability are called parallel algorithms . Still, studying the classic techniques for design and analysis of algorithms under the RAM model remains the cornerstone of algorithmics for the foreseeable future.

Should you worry about the speed and amount of memory of a computer at your disposal? If you are designing an algorithm as a scientific exercise, the answer is a qualified no. As you will see in Section 2.1, most computer scientists prefer to study algorithms in terms independent of specification parameters for a particular computer. If you are designing an algorithm as a practical tool, the answer may depend on a problem you need to solve. Even the “slow” computers of today are almost unimaginably fast. Consequently, in many situations you need not worry about a computer being too slow for the task. There are important problems, however, that are very complex by their nature, or have to process huge volumes of data, or deal with applications where the time is critical. In such situations, it is imperative to be aware of the speed and memory available on a particular computer system.

Choosing between Exact and Approximate Problem Solving

The next principal decision is to choose between solving the problem exactly or solving it approximately. In the former case, an algorithm is called an exact algo-rithm ; in the latter case, an algorithm is called an approximation algorithm . Why would one opt for an approximation algorithm? First, there are important prob-lems that simply cannot be solved exactly for most of their instances; examples include extracting square roots, solving nonlinear equations, and evaluating def-inite integrals. Second, available algorithms for solving a problem exactly can be unacceptably slow because of the problem’s intrinsic complexity. This happens, in particular, for many problems involving a very large number of choices; you will see examples of such difficult problems in Chapters 3, 11, and 12. Third, an ap-proximation algorithm can be a part of a more sophisticated algorithm that solves a problem exactly.

Algorithm Design Techniques

Now, with all the components of the algorithmic problem solving in place, how do you design an algorithm to solve a given problem? This is the main question this book seeks to answer by teaching you several general design techniques.

What is an algorithm design technique?

An algorithm design technique (or “strategy” or “paradigm”) is a general approach to solving problems algorithmically that is applicable to a variety of problems from different areas of computing.

Check this book’s table of contents and you will see that a majority of its chapters are devoted to individual design techniques. They distill a few key ideas that have proven to be useful in designing algorithms. Learning these techniques is of utmost importance for the following reasons.

First, they provide guidance for designing algorithms for new problems, i.e., problems for which there is no known satisfactory algorithm. Therefore—to use the language of a famous proverb—learning such techniques is akin to learning to fish as opposed to being given a fish caught by somebody else. It is not true, of course, that each of these general techniques will be necessarily applicable to every problem you may encounter. But taken together, they do constitute a powerful collection of tools that you will find quite handy in your studies and work.

Second, algorithms are the cornerstone of computer science. Every science is interested in classifying its principal subject, and computer science is no exception. Algorithm design techniques make it possible to classify algorithms according to an underlying design idea; therefore, they can serve as a natural way to both categorize and study algorithms.

Designing an Algorithm and Data Structures

While the algorithm design techniques do provide a powerful set of general ap-proaches to algorithmic problem solving, designing an algorithm for a particular problem may still be a challenging task. Some design techniques can be simply inapplicable to the problem in question. Sometimes, several techniques need to be combined, and there are algorithms that are hard to pinpoint as applications of the known design techniques. Even when a particular design technique is ap-plicable, getting an algorithm often requires a nontrivial ingenuity on the part of the algorithm designer. With practice, both tasks—choosing among the general techniques and applying them—get easier, but they are rarely easy.

Of course, one should pay close attention to choosing data structures appro-priate for the operations performed by the algorithm. For example, the sieve of Eratosthenes introduced in Section 1.1 would run longer if we used a linked list instead of an array in its implementation (why?). Also note that some of the al-gorithm design techniques discussed in Chapters 6 and 7 depend intimately on structuring or restructuring data specifying a problem’s instance. Many years ago, an influential textbook proclaimed the fundamental importance of both algo-rithms and data structures for computer programming by its very title: Algorithms + Data Structures = Programs [Wir76]. In the new world of object-oriented programming, data structures remain crucially important for both design and analysis of algorithms. We review basic data structures in Section 1.4.

Methods of Specifying an Algorithm

Once you have designed an algorithm, you need to specify it in some fashion. In Section 1.1, to give you an example, Euclid’s algorithm is described in words (in a free and also a step-by-step form) and in pseudocode. These are the two options that are most widely used nowadays for specifying algorithms.

Using a natural language has an obvious appeal; however, the inherent ambi-guity of any natural language makes a succinct and clear description of algorithms surprisingly difficult. Nevertheless, being able to do this is an important skill that you should strive to develop in the process of learning algorithms.

Pseudocode is a mixture of a natural language and programming language-like constructs. Pseudocode is usually more precise than natural language, and its usage often yields more succinct algorithm descriptions. Surprisingly, computer scientists have never agreed on a single form of pseudocode, leaving textbook authors with a need to design their own “dialects.” Fortunately, these dialects are so close to each other that anyone familiar with a modern programming language should be able to understand them all.

This book’s dialect was selected to cause minimal difficulty for a reader. For the sake of simplicity, we omit declarations of variables and use indentation to show the scope of such statements as for , if , and while . As you saw in the previous section, we use an arrow “ ← ” for the assignment operation and two slashes “ // ” for comments.

In the earlier days of computing, the dominant vehicle for specifying algo-rithms was a flowchart , a method of expressing an algorithm by a collection of connected geometric shapes containing descriptions of the algorithm’s steps. This representation technique has proved to be inconvenient for all but very simple algorithms; nowadays, it can be found only in old algorithm books.

The state of the art of computing has not yet reached a point where an algorithm’s description—be it in a natural language or pseudocode—can be fed into an electronic computer directly. Instead, it needs to be converted into a computer program written in a particular computer language. We can look at such a program as yet another way of specifying the algorithm, although it is preferable to consider it as the algorithm’s implementation.

Proving an Algorithm’s Correctness

Once an algorithm has been specified, you have to prove its correctness . That is, you have to prove that the algorithm yields a required result for every legitimate input in a finite amount of time. For example, the correctness of Euclid’s algorithm for computing the greatest common divisor stems from the correctness of the equality gcd (m, n) = gcd (n, m mod n) (which, in turn, needs a proof; see Problem 7 in Exercises 1.1), the simple observation that the second integer gets smaller on every iteration of the algorithm, and the fact that the algorithm stops when the second integer becomes 0.

For some algorithms, a proof of correctness is quite easy; for others, it can be quite complex. A common technique for proving correctness is to use mathemati-cal induction because an algorithm’s iterations provide a natural sequence of steps needed for such proofs. It might be worth mentioning that although tracing the algorithm’s performance for a few specific inputs can be a very worthwhile activ-ity, it cannot prove the algorithm’s correctness conclusively. But in order to show that an algorithm is incorrect, you need just one instance of its input for which the algorithm fails.

The notion of correctness for approximation algorithms is less straightforward than it is for exact algorithms. For an approximation algorithm, we usually would like to be able to show that the error produced by the algorithm does not exceed a predefined limit. You can find examples of such investigations in Chapter 12.

Analyzing an Algorithm

We usually want our algorithms to possess several qualities. After correctness, by far the most important is efficiency . In fact, there are two kinds of algorithm efficiency: time efficiency , indicating how fast the algorithm runs, and space ef-ficiency , indicating how much extra memory it uses. A general framework and specific techniques for analyzing an algorithm’s efficiency appear in Chapter 2.

Another desirable characteristic of an algorithm is simplicity . Unlike effi-ciency, which can be precisely defined and investigated with mathematical rigor, simplicity, like beauty, is to a considerable degree in the eye of the beholder. For example, most people would agree that Euclid’s algorithm is simpler than the middle-school procedure for computing gcd (m, n) , but it is not clear whether Eu-clid’s algorithm is simpler than the consecutive integer checking algorithm. Still, simplicity is an important algorithm characteristic to strive for. Why? Because sim-pler algorithms are easier to understand and easier to program; consequently, the resulting programs usually contain fewer bugs. There is also the undeniable aes-thetic appeal of simplicity. Sometimes simpler algorithms are also more efficient than more complicated alternatives. Unfortunately, it is not always true, in which case a judicious compromise needs to be made.

Yet another desirable characteristic of an algorithm is generality . There are, in fact, two issues here: generality of the problem the algorithm solves and the set of inputs it accepts. On the first issue, note that it is sometimes easier to design an algorithm for a problem posed in more general terms. Consider, for example, the problem of determining whether two integers are relatively prime, i.e., whether their only common divisor is equal to 1. It is easier to design an algorithm for a more general problem of computing the greatest common divisor of two integers and, to solve the former problem, check whether the gcd is 1 or not. There are situations, however, where designing a more general algorithm is unnecessary or difficult or even impossible. For example, it is unnecessary to sort a list of n numbers to find its median, which is its n/ 2 th smallest element. To give another example, the standard formula for roots of a quadratic equation cannot be generalized to handle polynomials of arbitrary degrees.

As to the set of inputs, your main concern should be designing an algorithm that can handle a set of inputs that is natural for the problem at hand. For example, excluding integers equal to 1 as possible inputs for a greatest common divisor algorithm would be quite unnatural. On the other hand, although the standard formula for the roots of a quadratic equation holds for complex coefficients, we would normally not implement it on this level of generality unless this capability is explicitly required.

If you are not satisfied with the algorithm’s efficiency, simplicity, or generality, you must return to the drawing board and redesign the algorithm. In fact, even if your evaluation is positive, it is still worth searching for other algorithmic solutions. Recall the three different algorithms in the previous section for computing the greatest common divisor: generally, you should not expect to get the best algorithm on the first try. At the very least, you should try to fine-tune the algorithm you already have. For example, we made several improvements in our implementation of the sieve of Eratosthenes compared with its initial outline in Section 1.1. (Can you identify them?) You will do well if you keep in mind the following observation of Antoine de Saint-Exupery,´ the French writer, pilot, and aircraft designer: “A designer knows he has arrived at perfection not when there is no longer anything to add, but when there is no longer anything to take away.” 1

Coding an Algorithm

Most algorithms are destined to be ultimately implemented as computer pro-grams. Programming an algorithm presents both a peril and an opportunity. The peril lies in the possibility of making the transition from an algorithm to a pro-gram either incorrectly or very inefficiently. Some influential computer scientists strongly believe that unless the correctness of a computer program is proven with full mathematical rigor, the program cannot be considered correct. They have developed special techniques for doing such proofs (see [Gri81]), but the power of these techniques of formal verification is limited so far to very small programs.

As a practical matter, the validity of programs is still established by testing. Testing of computer programs is an art rather than a science, but that does not mean that there is nothing in it to learn. Look up books devoted to testing and debugging; even more important, test and debug your program thoroughly whenever you implement an algorithm.

Also note that throughout the book, we assume that inputs to algorithms belong to the specified sets and hence require no verification. When implementing algorithms as programs to be used in actual applications, you should provide such verifications.

Of course, implementing an algorithm correctly is necessary but not sufficient: you would not like to diminish your algorithm’s power by an inefficient implemen-tation. Modern compilers do provide a certain safety net in this regard, especially when they are used in their code optimization mode. Still, you need to be aware of such standard tricks as computing a loop’s invariant (an expression that does not change its value) outside the loop, collecting common subexpressions, replac-ing expensive operations by cheap ones, and so on. (See [Ker99] and [Ben00] for a good discussion of code tuning and other issues related to algorithm program-ming.) Typically, such improvements can speed up a program only by a constant factor, whereas a better algorithm can make a difference in running time by orders of magnitude. But once an algorithm is selected, a 10–50% speedup may be worth an effort.

A working program provides an additional opportunity in allowing an em-pirical analysis of the underlying algorithm. Such an analysis is based on timing the program on several inputs and then analyzing the results obtained. We dis-cuss the advantages and disadvantages of this approach to analyzing algorithms in Section 2.6.

In conclusion, let us emphasize again the main lesson of the process depicted in Figure 1.2:

As a rule, a good algorithm is a result of repeated effort and rework.

Even if you have been fortunate enough to get an algorithmic idea that seems perfect, you should still try to see whether it can be improved.

Actually, this is good news since it makes the ultimate result so much more enjoyable. (Yes, I did think of naming this book The Joy of Algorithms .) On the other hand, how does one know when to stop? In the real world, more often than not a project’s schedule or the impatience of your boss will stop you. And so it should be: perfection is expensive and in fact not always called for. Designing an algorithm is an engineering-like activity that calls for compromises among competing goals under the constraints of available resources, with the designer’s time being one of the resources.

In the academic world, the question leads to an interesting but usually difficult investigation of an algorithm’s optimality . Actually, this question is not about the efficiency of an algorithm but about the complexity of the problem it solves: What is the minimum amount of effort any algorithm will need to exert to solve the problem? For some problems, the answer to this question is known. For example, any algorithm that sorts an array by comparing values of its elements needs about n log 2 n comparisons for some arrays of size n (see Section 11.2). But for many seemingly easy problems such as integer multiplication, computer scientists do not yet have a final answer.

Another important issue of algorithmic problem solving is the question of whether or not every problem can be solved by an algorithm. We are not talking here about problems that do not have a solution, such as finding real roots of a quadratic equation with a negative discriminant. For such cases, an output indicating that the problem does not have a solution is all we can and should expect from an algorithm. Nor are we talking about ambiguously stated problems. Even some unambiguous problems that must have a simple yes or no answer are “undecidable,” i.e., unsolvable by any algorithm. An important example of such a problem appears in Section 11.3. Fortunately, a vast majority of problems in practical computing can be solved by an algorithm.

Before leaving this section, let us be sure that you do not have the misconception—possibly caused by the somewhat mechanical nature of the diagram of Figure 1.2—that designing an algorithm is a dull activity. There is nothing further from the truth: inventing (or discovering?) algorithms is a very creative and rewarding process. This book is designed to convince you that this is the case.

Exercises 1.2

Old World puzzle A peasant finds himself on a riverbank with a wolf, a goat, and a head of cabbage. He needs to transport all three to the other side of the river in his boat. However, the boat has room for only the peasant himself and one other item (either the wolf, the goat, or the cabbage). In his absence, the wolf would eat the goat, and the goat would eat the cabbage. Solve this problem for the peasant or prove it has no solution. (Note: The peasant is a vegetarian but does not like cabbage and hence can eat neither the goat nor the cabbage to help him solve the problem. And it goes without saying that the wolf is a protected species.)

New World puzzle There are four people who want to cross a rickety bridge; they all begin on the same side. You have 17 minutes to get them all across to the other side. It is night, and they have one flashlight. A maximum of two people can cross the bridge at one time. Any party that crosses, either one or two people, must have the flashlight with them. The flashlight must be walked back and forth; it cannot be thrown, for example. Person 1 takes 1 minute to cross the bridge, person 2 takes 2 minutes, person 3 takes 5 minutes, and person 4 takes 10 minutes. A pair must walk together at the rate of the slower person’s pace. (Note: According to a rumor on the Internet, interviewers at a well-known software company located near Seattle have given this problem to interviewees.)

Which of the following formulas can be considered an algorithm for comput-ing the area of a triangle whose side lengths are given positive numbers a , b , and c ?

Write pseudocode for an algorithm for finding real roots of equation ax 2 + bx + c = 0 for arbitrary real coefficients a, b, and c. (You may assume the availability of the square root function sqrt (x). )

Describe the standard algorithm for finding the binary representation of a positive decimal integer

in English.

in pseudocode.

Describe the algorithm used by your favorite ATM machine in dispensing cash. (You may give your description in either English or pseudocode, which-ever you find more convenient.)

a. Can the problem of computing the number π be solved exactly?

How many instances does this problem have?

Look up an algorithm for this problem on the Internet.

Give an example of a problem other than computing the greatest common divisor for which you know more than one algorithm. Which of them is simpler? Which is more efficient?

Consider the following algorithm for finding the distance between the two closest elements in an array of numbers.

ALGORITHM MinDistance (A [0 ..n − 1] )

//Input: Array A [0 ..n − 1] of numbers

//Output: Minimum distance between two of its elements dmin ← ∞

for i ← 0 to n − 1 do

for j ← 0 to n − 1 do

if i = j and |A[i] − A[j ]| < dmin dmin ← |A[i] − A[j ]|

return dmin

Make as many improvements as you can in this algorithmic solution to the problem. If you need to, you may change the algorithm altogether; if not, improve the implementation given.

One of the most influential books on problem solving, titled How To Solve It [Pol57], was written by the Hungarian-American mathematician George Polya´ (1887–1985). Polya´ summarized his ideas in a four-point summary. Find this summary on the Internet or, better yet, in his book, and compare it with the plan outlined in Section 1.2. What do they have in common? How are they different?

Problem Solving with Algorithms and Data Structures using Python ¶

By Brad Miller and David Ranum, Luther College (as remixed by Jeffrey Elkner)

1.1. Objectives
1.2. Getting Started
1.3. What Is Computer Science?
1.4. What Is Programming?
1.5. Why Study Data Structures and Abstract Data Types?
1.6. Why Study Algorithms?
1.7. Review of Basic Python
1.8.1. Built-in Atomic Data Types
1.8.2. Built-in Collection Data Types
1.9.1. String Formatting
1.10. Control Structures
1.11. Exception Handling
1.12. Defining Functions
1.13.1. A Fraction Class
1.13.2. Inheritance: Logic Gates and Circuits
1.14. Summary
1.15. Key Terms
1.16. Discussion Questions
1.17. Programming Exercises
2.1. Objectives
2.2. What Is Algorithm Analysis?
2.3. Big-O Notation
2.4.1. Solution 1: Checking Off
2.4.2. Solution 2: Sort and Compare
2.4.3. Solution 3: Brute Force
2.4.4. Solution 4: Count and Compare
2.5. Performance of Python Data Structures
2.7. Dictionaries
2.8. Summary
2.9. Key Terms
2.10. Discussion Questions
2.11. Programming Exercises
3.1. Objectives
3.2. What Are Linear Structures?
3.3. What is a Stack?
3.4. The Stack Abstract Data Type
3.5. Implementing a Stack in Python
3.6. Simple Balanced Parentheses
3.7. Balanced Symbols (A General Case)
3.8. Converting Decimal Numbers to Binary Numbers
3.9.1. Conversion of Infix Expressions to Prefix and Postfix
3.9.2. General Infix-to-Postfix Conversion
3.9.3. Postfix Evaluation
3.10. What Is a Queue?
3.11. The Queue Abstract Data Type
3.12. Implementing a Queue in Python
3.13. Simulation: Hot Potato
3.14.1. Main Simulation Steps
3.14.2. Python Implementation
3.14.3. Discussion
3.15. What Is a Deque?
3.16. The Deque Abstract Data Type
3.17. Implementing a Deque in Python
3.18. Palindrome-Checker
3.19. Lists
3.20. The Unordered List Abstract Data Type
3.21.1. The Node Class
3.21.2. The Unordered List Class
3.22. The Ordered List Abstract Data Type
3.23.1. Analysis of Linked Lists
3.24. Summary
3.25. Key Terms
3.26. Discussion Questions
3.27. Programming Exercises
4.1. Objectives
4.2. What Is Recursion?
4.3. Calculating the Sum of a List of Numbers
4.4. The Three Laws of Recursion
4.5. Converting an Integer to a String in Any Base
4.6. Stack Frames: Implementing Recursion
4.7. Introduction: Visualizing Recursion
4.8. Sierpinski Triangle
4.9. Complex Recursive Problems
4.10. Tower of Hanoi
4.11. Exploring a Maze
4.12. Dynamic Programming
4.13. Summary
4.14. Key Terms
4.15. Discussion Questions
4.16. Glossary
4.17. Programming Exercises
5.1. Objectives
5.2. Searching
5.3.1. Analysis of Sequential Search
5.4.1. Analysis of Binary Search
5.5.1. Hash Functions
5.5.2. Collision Resolution
5.5.3. Implementing the Map Abstract Data Type
5.5.4. Analysis of Hashing
5.6. Sorting
5.7. The Bubble Sort
5.8. The Selection Sort
5.9. The Insertion Sort
5.10. The Shell Sort
5.11. The Merge Sort
5.12. The Quick Sort
5.13. Summary
5.14. Key Terms
5.15. Discussion Questions
5.16. Programming Exercises
6.1. Objectives
6.2. Examples of Trees
6.3. Vocabulary and Definitions
6.4. List of Lists Representation
6.5. Nodes and References
6.6. Parse Tree
6.7. Tree Traversals
6.8. Priority Queues with Binary Heaps
6.9. Binary Heap Operations
6.10.1. The Structure Property
6.10.2. The Heap Order Property
6.10.3. Heap Operations
6.11. Binary Search Trees
6.12. Search Tree Operations
6.13. Search Tree Implementation
6.14. Search Tree Analysis
6.15. Balanced Binary Search Trees
6.16. AVL Tree Performance
6.17. AVL Tree Implementation
6.18. Summary of Map ADT Implementations
6.19. Summary
6.20. Key Terms
6.21. Discussion Questions
6.22. Programming Exercises
7.1. Objectives
7.2. Vocabulary and Definitions
7.3. The Graph Abstract Data Type
7.4. An Adjacency Matrix
7.5. An Adjacency List
7.6. Implementation
7.7. The Word Ladder Problem
7.8. Building the Word Ladder Graph
7.9. Implementing Breadth First Search
7.10. Breadth First Search Analysis
7.11. The Knight’s Tour Problem
7.12. Building the Knight’s Tour Graph
7.13. Implementing Knight’s Tour
7.14. Knight’s Tour Analysis
7.15. General Depth First Search
7.16. Depth First Search Analysis
7.17. Topological Sorting
7.18. Strongly Connected Components
7.19. Shortest Path Problems
7.20. Dijkstra’s Algorithm
7.21. Analysis of Dijkstra’s Algorithm
7.22. Prim’s Spanning Tree Algorithm
7.23. Summary
7.24. Key Terms
7.25. Discussion Questions
7.26. Programming Exercises

Acknowledgements ¶

We are very grateful to Franklin Beedle Publishers for allowing us to make this interactive textbook freely available. This online version is dedicated to the memory of our first editor, Jim Leisy, who wanted us to “change the world.”

Indices and tables ¶

Module Index
Search Page

Runestone in social media: Follow @iRunestone Our Facebook Page
Table of Contents
Assignments
Peer Instruction (Instructor)
Peer Instruction (Student)
Change Course
Instructor's Page
Progress Page
Edit Profile
Change Password
Scratch ActiveCode
Scratch Activecode
Instructors Guide
About Runestone
Report A Problem
This Chapter
1. Introduction' data-toggle="tooltip" >

Problem Solving with Algorithms and Data Structures using Python ¶

By Brad Miller and David Ranum, Luther College

There is a wonderful collection of YouTube videos recorded by Gerry Jenkins to support all of the chapters in this text.

1.1. Objectives
1.2. Getting Started
1.3. What Is Computer Science?
1.4. What Is Programming?
1.5. Why Study Data Structures and Abstract Data Types?
1.6. Why Study Algorithms?
1.7. Review of Basic Python
1.8.1. Built-in Atomic Data Types
1.8.2. Built-in Collection Data Types
1.9.1. String Formatting
1.10. Control Structures
1.11. Exception Handling
1.12. Defining Functions
1.13.1. A Fraction Class
1.13.2. Inheritance: Logic Gates and Circuits
1.14. Summary
1.15. Key Terms
1.16. Discussion Questions
1.17. Programming Exercises
2.1.1. A Basic implementation of the MSDie class
2.2. Making your Class Comparable
3.1. Objectives
3.2. What Is Algorithm Analysis?
3.3. Big-O Notation
3.4.1. Solution 1: Checking Off
3.4.2. Solution 2: Sort and Compare
3.4.3. Solution 3: Brute Force
3.4.4. Solution 4: Count and Compare
3.5. Performance of Python Data Structures
3.7. Dictionaries
3.8. Summary
3.9. Key Terms
3.10. Discussion Questions
3.11. Programming Exercises
4.1. Objectives
4.2. What Are Linear Structures?
4.3. What is a Stack?
4.4. The Stack Abstract Data Type
4.5. Implementing a Stack in Python
4.6. Simple Balanced Parentheses
4.7. Balanced Symbols (A General Case)
4.8. Converting Decimal Numbers to Binary Numbers
4.9.1. Conversion of Infix Expressions to Prefix and Postfix
4.9.2. General Infix-to-Postfix Conversion
4.9.3. Postfix Evaluation
4.10. What Is a Queue?
4.11. The Queue Abstract Data Type
4.12. Implementing a Queue in Python
4.13. Simulation: Hot Potato
4.14.1. Main Simulation Steps
4.14.2. Python Implementation
4.14.3. Discussion
4.15. What Is a Deque?
4.16. The Deque Abstract Data Type
4.17. Implementing a Deque in Python
4.18. Palindrome-Checker
4.19. Lists
4.20. The Unordered List Abstract Data Type
4.21.1. The Node Class
4.21.2. The Unordered List Class
4.22. The Ordered List Abstract Data Type
4.23.1. Analysis of Linked Lists
4.24. Summary
4.25. Key Terms
4.26. Discussion Questions
4.27. Programming Exercises
5.1. Objectives
5.2. What Is Recursion?
5.3. Calculating the Sum of a List of Numbers
5.4. The Three Laws of Recursion
5.5. Converting an Integer to a String in Any Base
5.6. Stack Frames: Implementing Recursion
5.7. Introduction: Visualizing Recursion
5.8. Sierpinski Triangle
5.9. Complex Recursive Problems
5.10. Tower of Hanoi
5.11. Exploring a Maze
5.12. Dynamic Programming
5.13. Summary
5.14. Key Terms
5.15. Discussion Questions
5.16. Glossary
5.17. Programming Exercises
6.1. Objectives
6.2. Searching
6.3.1. Analysis of Sequential Search
6.4.1. Analysis of Binary Search
6.5.1. Hash Functions
6.5.2. Collision Resolution
6.5.3. Implementing the Map Abstract Data Type
6.5.4. Analysis of Hashing
6.6. Sorting
6.7. The Bubble Sort
6.8. The Selection Sort
6.9. The Insertion Sort
6.10. The Shell Sort
6.11. The Merge Sort
6.12. The Quick Sort
6.13. Summary
6.14. Key Terms
6.15. Discussion Questions
6.16. Programming Exercises
7.1. Objectives
7.2. Examples of Trees
7.3. Vocabulary and Definitions
7.4. List of Lists Representation
7.5. Nodes and References
7.6. Parse Tree
7.7. Tree Traversals
7.8. Priority Queues with Binary Heaps
7.9. Binary Heap Operations
7.10.1. The Structure Property
7.10.2. The Heap Order Property
7.10.3. Heap Operations
7.11. Binary Search Trees
7.12. Search Tree Operations
7.13. Search Tree Implementation
7.14. Search Tree Analysis
7.15. Balanced Binary Search Trees
7.16. AVL Tree Performance
7.17. AVL Tree Implementation
7.18. Summary of Map ADT Implementations
7.19. Summary
7.20. Key Terms
7.21. Discussion Questions
7.22. Programming Exercises
8.1. Objectives
8.2. Vocabulary and Definitions
8.3. The Graph Abstract Data Type
8.4. An Adjacency Matrix
8.5. An Adjacency List
8.6. Implementation
8.7. The Word Ladder Problem
8.8. Building the Word Ladder Graph
8.9. Implementing Breadth First Search
8.10. Breadth First Search Analysis
8.11. The Knight’s Tour Problem
8.12. Building the Knight’s Tour Graph
8.13. Implementing Knight’s Tour
8.14. Knight’s Tour Analysis
8.15. General Depth First Search
8.16. Depth First Search Analysis
8.17. Topological Sorting
8.18. Strongly Connected Components
8.19. Shortest Path Problems
8.20. Dijkstra’s Algorithm
8.21. Analysis of Dijkstra’s Algorithm
8.22. Prim’s Spanning Tree Algorithm
8.23. Summary
8.24. Key Terms
8.25. Discussion Questions
8.26. Programming Exercises

Acknowledgements ¶

Indices and tables ¶

Search Page

Get full access to Algorithmic Problem Solving and 60K+ other titles, with a free 10-day trial of O'Reilly.

There are also live events, courses curated by job role, and more.

Algorithmic Problem Solving

Read it now on the O’Reilly learning platform with a 10-day free trial.

O’Reilly members get unlimited access to books, live events, courses curated by job role, and more from O’Reilly and nearly 200 top publishers.

Book description

An entertaining and captivating way to learn the fundamentals of using algorithms to solve problems

The algorithmic approach to solving problems in computer technology is an essential tool. With this unique book, algorithm guru Roland Backhouse shares his four decades of experience to teach the fundamental principles of using algorithms to solve problems. Using fun and well-known puzzles to gradually introduce different aspects of algorithms in mathematics and computing. Backhouse presents you with a readable, entertaining, and energetic book that will motivate and challenge you to open your mind to the algorithmic nature of problem solving.

Provides a novel approach to the mathematics of problem solving focusing on the algorithmic nature of problem solving

Uses popular and entertaining puzzles to teach you different aspects of using algorithms to solve mathematical and computing challenges

Features a theory section that supports each of the puzzles presented throughout the book

Assumes only an elementary understanding of mathematics

Let Roland Backhouse and his four decades of experience show you how you can solve challenging problems with algorithms!

1.1 Algorithms
1.2 Algorithmic Problem Solving
1.3 Overview
1.4 Bibliographic Remarks
2.1 Chocolate Bars
2.2 Empty Boxes
2.3 The Tumbler Problem
2.4 Tetrominoes
2.5 Summary
2.6 Bibliographic Remarks
3.1 Problems
3.2 Brute Force
3.3 Nervous Couples
3.4 Rule of Sequential Composition
3.5 The Bridge Problem
3.6 Conditional Statements
3.7 Summary
3.8 Bibliographic Remarks
4.1 Matchstick Games
4.2 Winning Strategies
4.3 Subtraction-Set Games
4.4 Sums of Games
4.5 Summary
4.6 Bibliographic Remarks
5.1 Logic Puzzles
5.2 Calculational Logic
5.3 Equivalence and Continued Equalities
5.4 Negation
5.5 Summary
5.6 Bibliographic Remarks
6.1 Example Problems
6.2 Cutting the Plane
6.3 Triominoes
6.4 Looking for Patterns
6.5 The Need for Proof
6.6 From Verification to Construction
6.7 Summary
6.8 Bibliographic Remarks
7.1 Problem Formulation
7.2 Problem Solution
7.3 Summary
7.4 Bibliographic Remarks
8.1 Specification and Solution
8.2 Inductive Solution
8.3 The Iterative Solution
8.4 Summary
8.5 Bibliographic Remarks
9.1 Iteration, Invariants and Making Progress
9.2 A Simple Sorting Problem
9.3 Binary Search
9.4 Sam Loyd’s Chicken-Chasing Problem
9.5 Projects
9.6 Summary
9.7 Bibliographic Remarks
10.1 Lower and Upper Bounds
10.2 Outline Strategy
10.3 Regular Sequences
10.4 Sequencing Forward Trips
10.5 Choosing Settlers and Nomads
10.6 The Algorithm
10.7 Summary
10.8 Bibliographic Remarks
11.1 Straight-Move Circuits
11.2 Supersquares
11.3 Partitioning the Board
11.4 Summary
11.5 Bibliographic Remarks
12.1 Variables, Expressions and Laws
12.3 Functions
12.4 Types and Type Checking
12.5 Algebraic Properties
12.6 Boolean Operators
12.7 Binary Relations
12.8 Calculations
12.9 Exercises
13.1 Boolean Equality
13.2 Negation
13.3 Disjunction
13.4 Conjunction
13.5 Implication
13.6 Set Calculus
13.7 Exercises
14.1 DotDotDot and Sigmas
14.2 Introducing Quantifier Notation
14.3 Universal and Existential Quantification
14.4 Quantifier Rules
14.5 Exercises
15.1 Inequalities
15.2 Minimum and Maximum
15.3 The Divides Relation
15.4 Modular Arithmetic
15.5 Exercises
16.1 Paths in a Directed Graph
16.2 Graphs and Relations
16.3 Functional and Total Relations
16.4 Path-Finding Problems
16.5 Matrices
16.6 Closure Operators
16.7 Acyclic Graphs
16.8 Combinatorics
16.9 Exercises
Solutions to Exercises

Product information

Title: Algorithmic Problem Solving
Release date: December 2011
Publisher(s): Wiley
ISBN: 9780470684535

How to solve almost any problem.

by Alan Barker

Problems block and slow down your progress; here’s how to overcome them–simply, efficiently and effectively. This …

Difficult Conversations

by Harvard Business Review

You have to talk with a colleague about a fraught situation, but you're worried that they'll …

Problem Solving

by V. Anton Spraul

The real challenge of programming isn't learning a language's syntax—it's learning to creatively solve problems so …

Generative AI in the Real World: Putting AI in the Hands of Farmers with Rikin Gandhi

by Rikin Gandhi

If you want to fine-tune your prompting skills, make sure to attend O’Reilly’s Prompt to Product …

Don’t leave empty-handed

Get Mark Richards’s Software Architecture Patterns ebook to better understand how to design components—and how they should interact.

It’s yours, free.

Check it out now on O’Reilly

Dive in for free with a 10-day trial of the O’Reilly learning platform—then explore all the other resources our members count on to build skills and solve problems every day.

1. Micro-Worlds
2. Light-Bot in Java
3. Jeroos of Santong Island
4. Problem Solving and Algorithms
5. Creating Jeroo Methods
6. Conditionally Executing Actions
7. Repeating Actions
8. Handling Touch Events
9. Adding Text to the Screen

Problem Solving and Algorithms

Learn a basic process for developing a solution to a problem. Nothing in this chapter is unique to using a computer to solve a problem. This process can be used to solve a wide variety of problems, including ones that have nothing to do with computers.

Problems, Solutions, and Tools

I have a problem! I need to thank Aunt Kay for the birthday present she sent me. I could send a thank you note through the mail. I could call her on the telephone. I could send her an email message. I could drive to her house and thank her in person. In fact, there are many ways I could thank her, but that's not the point. The point is that I must decide how I want to solve the problem, and use the appropriate tool to implement (carry out) my plan. The postal service, the telephone, the internet, and my automobile are tools that I can use, but none of these actually solves my problem. In a similar way, a computer does not solve problems, it's just a tool that I can use to implement my plan for solving the problem.

Knowing that Aunt Kay appreciates creative and unusual things, I have decided to hire a singing messenger to deliver my thanks. In this context, the messenger is a tool, but one that needs instructions from me. I have to tell the messenger where Aunt Kay lives, what time I would like the message to be delivered, and what lyrics I want sung. A computer program is similar to my instructions to the messenger.

The story of Aunt Kay uses a familiar context to set the stage for a useful point of view concerning computers and computer programs. The following list summarizes the key aspects of this point of view.

A computer is a tool that can be used to implement a plan for solving a problem.

A computer program is a set of instructions for a computer. These instructions describe the steps that the computer must follow to implement a plan.

An algorithm is a plan for solving a problem.

A person must design an algorithm.

A person must translate an algorithm into a computer program.

This point of view sets the stage for a process that we will use to develop solutions to Jeroo problems. The basic process is important because it can be used to solve a wide variety of problems, including ones where the solution will be written in some other programming language.

An Algorithm Development Process

Every problem solution starts with a plan. That plan is called an algorithm.

There are many ways to write an algorithm. Some are very informal, some are quite formal and mathematical in nature, and some are quite graphical. The instructions for connecting a DVD player to a television are an algorithm. A mathematical formula such as πR 2 is a special case of an algorithm. The form is not particularly important as long as it provides a good way to describe and check the logic of the plan.

The development of an algorithm (a plan) is a key step in solving a problem. Once we have an algorithm, we can translate it into a computer program in some programming language. Our algorithm development process consists of five major steps.

Step 1: Obtain a description of the problem.

Step 2: analyze the problem., step 3: develop a high-level algorithm., step 4: refine the algorithm by adding more detail., step 5: review the algorithm..

This step is much more difficult than it appears. In the following discussion, the word client refers to someone who wants to find a solution to a problem, and the word developer refers to someone who finds a way to solve the problem. The developer must create an algorithm that will solve the client's problem.

The client is responsible for creating a description of the problem, but this is often the weakest part of the process. It's quite common for a problem description to suffer from one or more of the following types of defects: (1) the description relies on unstated assumptions, (2) the description is ambiguous, (3) the description is incomplete, or (4) the description has internal contradictions. These defects are seldom due to carelessness by the client. Instead, they are due to the fact that natural languages (English, French, Korean, etc.) are rather imprecise. Part of the developer's responsibility is to identify defects in the description of a problem, and to work with the client to remedy those defects.

The purpose of this step is to determine both the starting and ending points for solving the problem. This process is analogous to a mathematician determining what is given and what must be proven. A good problem description makes it easier to perform this step.

When determining the starting point, we should start by seeking answers to the following questions:

What data are available?

Where is that data?

What formulas pertain to the problem?

What rules exist for working with the data?

What relationships exist among the data values?

When determining the ending point, we need to describe the characteristics of a solution. In other words, how will we know when we're done? Asking the following questions often helps to determine the ending point.

What new facts will we have?

What items will have changed?

What changes will have been made to those items?

What things will no longer exist?

An algorithm is a plan for solving a problem, but plans come in several levels of detail. It's usually better to start with a high-level algorithm that includes the major part of a solution, but leaves the details until later. We can use an everyday example to demonstrate a high-level algorithm.

Problem: I need a send a birthday card to my brother, Mark.

Analysis: I don't have a card. I prefer to buy a card rather than make one myself.

High-level algorithm:

Go to a store that sells greeting cards Select a card Purchase a card Mail the card

This algorithm is satisfactory for daily use, but it lacks details that would have to be added were a computer to carry out the solution. These details include answers to questions such as the following.

"Which store will I visit?"

"How will I get there: walk, drive, ride my bicycle, take the bus?"

"What kind of card does Mark like: humorous, sentimental, risqué?"

These kinds of details are considered in the next step of our process.

A high-level algorithm shows the major steps that need to be followed to solve a problem. Now we need to add details to these steps, but how much detail should we add? Unfortunately, the answer to this question depends on the situation. We have to consider who (or what) is going to implement the algorithm and how much that person (or thing) already knows how to do. If someone is going to purchase Mark's birthday card on my behalf, my instructions have to be adapted to whether or not that person is familiar with the stores in the community and how well the purchaser known my brother's taste in greeting cards.

When our goal is to develop algorithms that will lead to computer programs, we need to consider the capabilities of the computer and provide enough detail so that someone else could use our algorithm to write a computer program that follows the steps in our algorithm. As with the birthday card problem, we need to adjust the level of detail to match the ability of the programmer. When in doubt, or when you are learning, it is better to have too much detail than to have too little.

Most of our examples will move from a high-level to a detailed algorithm in a single step, but this is not always reasonable. For larger, more complex problems, it is common to go through this process several times, developing intermediate level algorithms as we go. Each time, we add more detail to the previous algorithm, stopping when we see no benefit to further refinement. This technique of gradually working from a high-level to a detailed algorithm is often called stepwise refinement .

The final step is to review the algorithm. What are we looking for? First, we need to work through the algorithm step by step to determine whether or not it will solve the original problem. Once we are satisfied that the algorithm does provide a solution to the problem, we start to look for other things. The following questions are typical of ones that should be asked whenever we review an algorithm. Asking these questions and seeking their answers is a good way to develop skills that can be applied to the next problem.

Does this algorithm solve a very specific problem or does it solve a more general problem ? If it solves a very specific problem, should it be generalized?

For example, an algorithm that computes the area of a circle having radius 5.2 meters (formula π*5.2 2 ) solves a very specific problem, but an algorithm that computes the area of any circle (formula π*R 2 ) solves a more general problem.

Can this algorithm be simplified ?

One formula for computing the perimeter of a rectangle is:

length + width + length + width

A simpler formula would be:

2.0 * ( length + width )

Is this solution similar to the solution to another problem? How are they alike? How are they different?

For example, consider the following two formulae:

Rectangle area = length * width Triangle area = 0.5 * base * height

Similarities: Each computes an area. Each multiplies two measurements.

Differences: Different measurements are used. The triangle formula contains 0.5.

Hypothesis: Perhaps every area formula involves multiplying two measurements.

Example 4.1: Pick and Plant

This section contains an extended example that demonstrates the algorithm development process. To complete the algorithm, we need to know that every Jeroo can hop forward, turn left and right, pick a flower from its current location, and plant a flower at its current location.

Problem Statement (Step 1)

A Jeroo starts at (0, 0) facing East with no flowers in its pouch. There is a flower at location (3, 0). Write a program that directs the Jeroo to pick the flower and plant it at location (3, 2). After planting the flower, the Jeroo should hop one space East and stop. There are no other nets, flowers, or Jeroos on the island.

Start	Finish

Analysis of the Problem (Step 2)

The flower is exactly three spaces ahead of the jeroo.

The flower is to be planted exactly two spaces South of its current location.

The Jeroo is to finish facing East one space East of the planted flower.

There are no nets to worry about.

High-level Algorithm (Step 3)

Let's name the Jeroo Bobby. Bobby should do the following:

Get the flower Put the flower Hop East

Detailed Algorithm (Step 4)

Get the flower Hop 3 times Pick the flower Put the flower Turn right Hop 2 times Plant a flower Hop East Turn left Hop once

Review the Algorithm (Step 5)

The high-level algorithm partitioned the problem into three rather easy subproblems. This seems like a good technique.

This algorithm solves a very specific problem because the Jeroo and the flower are in very specific locations.

This algorithm is actually a solution to a slightly more general problem in which the Jeroo starts anywhere, and the flower is 3 spaces directly ahead of the Jeroo.

Java Code for "Pick and Plant"

A good programmer doesn't write a program all at once. Instead, the programmer will write and test the program in a series of builds. Each build adds to the previous one. The high-level algorithm will guide us in this process.

FIRST BUILD

To see this solution in action, create a new Greenfoot4Sofia scenario and use the Edit Palettes Jeroo menu command to make the Jeroo classes visible. Right-click on the Island class and create a new subclass with the name of your choice. This subclass will hold your new code.

The recommended first build contains three things:

The main method (here myProgram() in your island subclass).

Declaration and instantiation of every Jeroo that will be used.

The high-level algorithm in the form of comments.

The instantiation at the beginning of myProgram() places bobby at (0, 0), facing East, with no flowers.

Once the first build is working correctly, we can proceed to the others. In this case, each build will correspond to one step in the high-level algorithm. It may seem like a lot of work to use four builds for such a simple program, but doing so helps establish habits that will become invaluable as the programs become more complex.

SECOND BUILD

This build adds the logic to "get the flower", which in the detailed algorithm (step 4 above) consists of hopping 3 times and then picking the flower. The new code is indicated by comments that wouldn't appear in the original (they are just here to call attention to the additions). The blank lines help show the organization of the logic.

By taking a moment to run the work so far, you can confirm whether or not this step in the planned algorithm works as expected.

THIRD BUILD

This build adds the logic to "put the flower". New code is indicated by the comments that are provided here to mark the additions.

FOURTH BUILD (final)

Example 4.2: replace net with flower.

This section contains a second example that demonstrates the algorithm development process.

There are two Jeroos. One Jeroo starts at (0, 0) facing North with one flower in its pouch. The second starts at (0, 2) facing East with one flower in its pouch. There is a net at location (3, 2). Write a program that directs the first Jeroo to give its flower to the second one. After receiving the flower, the second Jeroo must disable the net, and plant a flower in its place. After planting the flower, the Jeroo must turn and face South. There are no other nets, flowers, or Jeroos on the island.

Jeroo_2 is exactly two spaces behind Jeroo_1.

The only net is exactly three spaces ahead of Jeroo_2.

Each Jeroo has exactly one flower.

Jeroo_2 will have two flowers after receiving one from Jeroo_1. One flower must be used to disable the net. The other flower must be planted at the location of the net, i.e. (3, 2).

Jeroo_1 will finish at (0, 1) facing South.

Jeroo_2 is to finish at (3, 2) facing South.

Each Jeroo will finish with 0 flowers in its pouch. One flower was used to disable the net, and the other was planted.

Let's name the first Jeroo Ann and the second one Andy.

Ann should do the following: Find Andy (but don't collide with him) Give a flower to Andy (he will be straight ahead) After receiving the flower, Andy should do the following: Find the net (but don't hop onto it) Disable the net Plant a flower at the location of the net Face South

Ann should do the following: Find Andy Turn around (either left or right twice) Hop (to location (0, 1)) Give a flower to Andy Give ahead Now Andy should do the following: Find the net Hop twice (to location (2, 2)) Disable the net Toss Plant a flower at the location of the net Hop (to location (3, 2)) Plant a flower Face South Turn right

The high-level algorithm helps manage the details.

This algorithm solves a very specific problem, but the specific locations are not important. The only thing that is important is the starting location of the Jeroos relative to one another and the location of the net relative to the second Jeroo's location and direction.

Java Code for "Replace Net with Flower"

As before, the code should be written incrementally as a series of builds. Four builds will be suitable for this problem. As usual, the first build will contain the main method, the declaration and instantiation of the Jeroo objects, and the high-level algorithm in the form of comments. The second build will have Ann give her flower to Andy. The third build will have Andy locate and disable the net. In the final build, Andy will place the flower and turn East.

This build creates the main method, instantiates the Jeroos, and outlines the high-level algorithm. In this example, the main method would be myProgram() contained within a subclass of Island .

This build adds the logic for Ann to locate Andy and give him a flower.

This build adds the logic for Andy to locate and disable the net.

This build adds the logic for Andy to place a flower at (3, 2) and turn South.

Analysis of Algorithms
Backtracking
Dynamic Programming
Divide and Conquer
Geometric Algorithms
Mathematical Algorithms
Pattern Searching
Bitwise Algorithms
Branch & Bound
Randomized Algorithms

How to develop an Algorithm from Scratch | Develop Algorithmic Thinking

Algorithms are step-by-step instructions used to solve problems. Developing algorithmic thinking helps in breaking down complex problems into smaller problems and then solving the smaller problems and combining them to make solutions for that complex problem.

Developing Algorithmic Thinking via Solving Puzzles:

Solving puzzles and brain teasers helps enhance logical reasoning and problem-solving skills.
Analyse patterns used to solve puzzles and identify already defined algorithms like greedy algorithms, dynamic programming, or recursion.
For example, solving Sudoku puzzles can improve logical reasoning, and identifying the backtracking algorithm used in solving Sudoku can enhance algorithmic thinking.

Developing Algorithmic Thinking via Practicing Steps of Problem-Solving:

Understand the problem statement, and identify inputs, and desired output.
Break down the problem into smaller subproblems to handle complexity.
Determine the logic needed to solve each subproblem efficiently.
Combine the solutions of subproblems to solve the main problem.
For instance, in a maze-solving problem, breaking it down into finding a path from start to end in smaller sub-mazes simplifies the overall task.

How to solve a problem using Algorithmic Thinking:

Identify problem requirements and constraints for a clear understanding.
Break the problem into smaller, manageable subproblems.
Design an algorithm to solve each subproblem effectively.
Combine the solutions of subproblems to solve the main problem efficiently.
An example could be the problem of finding the shortest path in a graph using Dijkstra’s algorithm for each node to the destination.

Benefits of Algorithmic Thinking:

Improves problem-solving skills and efficiency, leading to optimized solutions.
Enhances logical reasoning and critical thinking abilities.
Enables a systematic and organized approach to tackle complex problems.
Identifies areas for improvement in existing solutions.
For illustration, algorithmic thinking can be applied to optimize transportation routes for efficient delivery services.

Thought of Optimization in Algorithmic Thinking:

Analyse the algorithm’s time and space complexity to understand efficiency.
Optimize algorithms by reducing time complexity and improving data structures used.
For example, implementing quicksort algorithm for efficient sorting of large datasets.

Algorithmic Thinking via Understanding Real-life Applications:

Identify real-life scenarios where algorithms are widely used, such as in shopping websites for sorting prices or recommendation systems.
Study existing algorithms and their applications in finance, healthcare, data analysis, etc.
Understand how algorithms solve complex problems and improve efficiency in various real-world scenarios.
A concrete example is how search engines use algorithms like PageRank to rank web pages based on relevance and popularity.

Conclusion:

Developing algorithmic thinking is an ongoing process that requires continuous practice, problem-solving, and exploration of various algorithms. By applying algorithmic thinking, you can develop effective and efficient solutions to a wide range of problems, enabling you to take complex challenges in a structured and logical manner.

Please Login to comment...

Improve your Coding Skills with Practice

What kind of Experience do you want to share?

Want to create or adapt books like this? Learn more about how Pressbooks supports open publishing practices.

8.2 Problem-Solving: Heuristics and Algorithms

Learning objectives.

Describe the differences between heuristics and algorithms in information processing.

When faced with a problem to solve, should you go with intuition or with more measured, logical reasoning? Obviously, we use both of these approaches. Some of the decisions we make are rapid, emotional, and automatic. Daniel Kahneman (2011) calls this “fast” thinking. By definition, fast thinking saves time. For example, you may quickly decide to buy something because it is on sale; your fast brain has perceived a bargain, and you go for it quickly. On the other hand, “slow” thinking requires more effort; applying this in the same scenario might cause us not to buy the item because we have reasoned that we don’t really need it, that it is still too expensive, and so on. Using slow and fast thinking does not guarantee good decision-making if they are employed at the wrong time. Sometimes it is not clear which is called for, because many decisions have a level of uncertainty built into them. In this section, we will explore some of the applications of these tendencies to think fast or slow.

We will look further into our thought processes, more specifically, into some of the problem-solving strategies that we use. Heuristics are information-processing strategies that are useful in many cases but may lead to errors when misapplied. A heuristic is a principle with broad application, essentially an educated guess about something. We use heuristics all the time, for example, when deciding what groceries to buy from the supermarket, when looking for a library book, when choosing the best route to drive through town to avoid traffic congestion, and so on. Heuristics can be thought of as aids to decision making; they allow us to reach a solution without a lot of cognitive effort or time.

The benefit of heuristics in helping us reach decisions fairly easily is also the potential downfall: the solution provided by the use of heuristics is not necessarily the best one. Let’s consider some of the most frequently applied, and misapplied, heuristics in the table below.

Table 8.1. Heuristics that pose threats to accuracy
Heuristic	Description	Examples of Threats to Accuracy
Representativeness	A judgment that something that is more representative of its category is more likely to occur	We may overestimate the likelihood that a person belongs to a particular category because they resemble our prototype of that category.
Availability	A judgment that what comes easily to mind is common	We may overestimate the crime statistics in our own area because these crimes are so easy to recall.
Anchoring and adjustment	A tendency to use a given starting point as the basis for a subsequent judgment	We may be swayed towards or away from decisions based on the starting point, which may be inaccurate.

In many cases, we base our judgments on information that seems to represent, or match, what we expect will happen, while ignoring other potentially more relevant statistical information. When we do so, we are using the representativeness heuristic . Consider, for instance, the data presented in the table below. Let’s say that you went to a hospital, and you checked the records of the babies that were born on that given day. Which pattern of births do you think you are most likely to find?

Table 8.2. The representativeness heuristic

6:31 a.m.	Girl	6:31 a.m.	Boy
8:15 a.m.	Girl	8:15 a.m.	Girl
9:42 a.m.	Girl	9:42 a.m.	Boy
1:13 p.m.	Girl	1:13 p.m.	Girl
3:39 p.m.	Boy	3:39 p.m.	Girl
5:12 p.m.	Boy	5:12 p.m.	Boy
7:42 p.m.	Boy	7:42 p.m.	Girl
11:44 p.m.	Boy	11:44 p.m.	Boy
Using the representativeness heuristic may lead us to incorrectly believe that some patterns of observed events are more likely to have occurred than others. In this case, list B seems more random, and thus is judged as more likely to have occurred, but statistically both lists are equally likely.

Most people think that list B is more likely, probably because list B looks more random, and matches — or is “representative of” — our ideas about randomness, but statisticians know that any pattern of four girls and four boys is mathematically equally likely. Whether a boy or girl is born first has no bearing on what sex will be born second; these are independent events, each with a 50:50 chance of being a boy or a girl. The problem is that we have a schema of what randomness should be like, which does not always match what is mathematically the case. Similarly, people who see a flipped coin come up “heads” five times in a row will frequently predict, and perhaps even wager money, that “tails” will be next. This behaviour is known as the gambler’s fallacy . Mathematically, the gambler’s fallacy is an error: the likelihood of any single coin flip being “tails” is always 50%, regardless of how many times it has come up “heads” in the past.

The representativeness heuristic may explain why we judge people on the basis of appearance. Suppose you meet your new next-door neighbour, who drives a loud motorcycle, has many tattoos, wears leather, and has long hair. Later, you try to guess their occupation. What comes to mind most readily? Are they a teacher? Insurance salesman? IT specialist? Librarian? Drug dealer? The representativeness heuristic will lead you to compare your neighbour to the prototypes you have for these occupations and choose the one that they seem to represent the best. Thus, your judgment is affected by how much your neibour seems to resemble each of these groups. Sometimes these judgments are accurate, but they often fail because they do not account for base rates , which is the actual frequency with which these groups exist. In this case, the group with the lowest base rate is probably drug dealer.

Our judgments can also be influenced by how easy it is to retrieve a memory. The tendency to make judgments of the frequency or likelihood that an event occurs on the basis of the ease with which it can be retrieved from memory is known as the availability heuristic (MacLeod & Campbell, 1992; Tversky & Kahneman, 1973). Imagine, for instance, that I asked you to indicate whether there are more words in the English language that begin with the letter “R” or that have the letter “R” as the third letter. You would probably answer this question by trying to think of words that have each of the characteristics, thinking of all the words you know that begin with “R” and all that have “R” in the third position. Because it is much easier to retrieve words by their first letter than by their third, we may incorrectly guess that there are more words that begin with “R,” even though there are in fact more words that have “R” as the third letter.

The availability heuristic may explain why we tend to overestimate the likelihood of crimes or disasters; those that are reported widely in the news are more readily imaginable, and therefore, we tend to overestimate how often they occur. Things that we find easy to imagine, or to remember from watching the news, are estimated to occur frequently. Anything that gets a lot of news coverage is easy to imagine. Availability bias does not just affect our thinking. It can change behaviour. For example, homicides are usually widely reported in the news, leading people to make inaccurate assumptions about the frequency of murder. In Canada, the murder rate has dropped steadily since the 1970s (Statistics Canada, 2018), but this information tends not to be reported, leading people to overestimate the probability of being affected by violent crime. In another example, doctors who recently treated patients suffering from a particular condition were more likely to diagnose the condition in subsequent patients because they overestimated the prevalence of the condition (Poses & Anthony, 1991).

The anchoring and adjustment heuristic is another example of how fast thinking can lead to a decision that might not be optimal. Anchoring and adjustment is easily seen when we are faced with buying something that does not have a fixed price. For example, if you are interested in a used car, and the asking price is $10,000, what price do you think you might offer? Using $10,000 as an anchor, you are likely to adjust your offer from there, and perhaps offer $9000 or $9500. Never mind that $10,000 may not be a reasonable anchoring price. Anchoring and adjustment does not just happen when we’re buying something. It can also be used in any situation that calls for judgment under uncertainty, such as sentencing decisions in criminal cases (Bennett, 2014), and it applies to groups as well as individuals (Rutledge, 1993).

In contrast to heuristics, which can be thought of as problem-solving strategies based on educated guesses, algorithms are problem-solving strategies that use rules. Algorithms are generally a logical set of steps that, if applied correctly, should be accurate. For example, you could make a cake using heuristics — relying on your previous baking experience and guessing at the number and amount of ingredients, baking time, and so on — or using an algorithm. The latter would require a recipe which would provide step-by-step instructions; the recipe is the algorithm. Unless you are an extremely accomplished baker, the algorithm should provide you with a better cake than using heuristics would. While heuristics offer a solution that might be correct, a correctly applied algorithm is guaranteed to provide a correct solution. Of course, not all problems can be solved by algorithms.

As with heuristics, the use of algorithmic processing interacts with behaviour and emotion. Understanding what strategy might provide the best solution requires knowledge and experience. As we will see in the next section, we are prone to a number of cognitive biases that persist despite knowledge and experience.

Key Takeaways

We use a variety of shortcuts in our information processing, such as the representativeness, availability, and anchoring and adjustment heuristics. These help us to make fast judgments but may lead to errors.
Algorithms are problem-solving strategies that are based on rules rather than guesses. Algorithms, if applied correctly, are far less likely to result in errors or incorrect solutions than heuristics. Algorithms are based on logic.

Bennett, M. W. (2014). Confronting cognitive ‘anchoring effect’ and ‘blind spot’ biases in federal sentencing: A modest solution for reforming and fundamental flaw. Journal of Criminal Law and Criminology , 104 (3), 489-534.

Kahneman, D. (2011). Thinking, fast and slow. New York, NY: Farrar, Straus and Giroux.

MacLeod, C., & Campbell, L. (1992). Memory accessibility and probability judgments: An experimental evaluation of the availability heuristic. Journal of Personality and Social Psychology, 63 (6), 890–902.

Poses, R. M., & Anthony, M. (1991). Availability, wishful thinking, and physicians’ diagnostic judgments for patients with suspected bacteremia. Medical Decision Making, 11 , 159-68.

Rutledge, R. W. (1993). The effects of group decisions and group-shifts on use of the anchoring and adjustment heuristic. Social Behavior and Personality, 21 (3), 215-226.

Statistics Canada. (2018). Ho micide in Canada, 2017 . Retrieved from https://www150.statcan.gc.ca/n1/en/daily-quotidien/181121/dq181121a-eng.pdf

Tversky, A., & Kahneman, D. (1973). Availability: A heuristic for judging frequency and probability. Cognitive Psychology, 5 , 207–232.

Share This Book

Bipolar Disorder
Therapy Center
When To See a Therapist
Types of Therapy
Best Online Therapy
Best Couples Therapy
Managing Stress
Sleep and Dreaming
Understanding Emotions
Self-Improvement
Healthy Relationships
Student Resources
Personality Types
Sweepstakes
Guided Meditations
Verywell Mind Insights
2024 Verywell Mind 25
Mental Health in the Classroom
Editorial Process
Meet Our Review Board
Crisis Support

What Is an Algorithm in Psychology?

Definition, Examples, and Uses

How Does an Algorithm Work?

Examples of algorithms.

Reasons to Use Algorithms
Potential Pitfalls

Algorithms vs. Heuristics

When solving a problem , choosing the right approach is often the key to arriving at the best solution. In psychology, one of these problem-solving approaches is known as an algorithm. While often thought of purely as a mathematical term, the same type of process can be followed in psychology to find the correct answer when solving a problem or making a decision.

An algorithm is a defined set of step-by-step procedures that provides the correct answer to a particular problem. By following the instructions correctly, you are guaranteed to arrive at the right answer.

At a Glance

Algorithms involve following specific steps in order to reach a solution to a problem. They can be a great tool when you need an accurate solution but tend to be more time-consuming than other methods.

This article discusses how algorithms are used as an approach to problem-solving. It also covers how psychologists compare this approach to other problem-solving methods.

An algorithm is often expressed in the form of a graph, where a square represents each step. Arrows then branch off from each step to point to possible directions that you may take to solve the problem.

In some cases, you must follow a particular set of steps to solve the problem. In other instances, you might be able to follow different paths that will all lead to the same solution.

Algorithms are essential step-by-step approaches to solving a problem. Rather than guessing or using trial-and-error, this approach is more likely to guarantee a specific solution.

Using an algorithm can help you solve day-to-day problems you face, but it can also help mental health professionals find ways to help people cope with mental health problems.

For example, a therapist might use an algorithm to treat a person experiencing something like anxiety. Because the therapist knows that a particular approach is likely to be effective, they would recommend a series of specific, focused steps as part of their intervention.

There are many different examples of how algorithms can be used in daily life. Some common ones include:

A recipe for cooking a particular dish
The method a search engine uses to find information on the internet
Instructions for how to assemble a bicycle
Instructions for how to solve a Rubik's cube
A process to determine what type of treatment is most appropriate for certain types of mental health conditions

Doctors and mental health professionals often use algorithms to diagnose mental disorders . For example, they may use a step-by-step approach when they evaluate people.

This might involve asking the individual about their symptoms and their medical history. The doctor may also conduct lab tests, physical exams, or psychological assessments.

Using this information, they then utilize the "Diagnostic and Statistical Manual of Mental Disorders" (DSM-5-TR) to make a diagnosis.

Reasons to Use Algorithms in Psychology

The upside of using an algorithm to solve a problem or make a decision is that yields the best possible answer every time. There are situations where using an algorithm can be the best approach:

When Accuracy Is Crucial

Algorithms can be particularly useful in situations when accuracy is critical. They are also a good choice when similar problems need to be frequently solved.

Computer programs can often be designed to speed up this process. Data then needs to be placed in the system so that the algorithm can be executed for the correct solution.

Artificial intelligence may also be a tool for making clinical assessments in healthcare situations.

When Each Decision Needs to Follow the Same Process

Such step-by-step approaches can be useful in situations where each decision must be made following the same process. Because the process follows a prescribed procedure, you can be sure that you will reach the correct answer each time.

Potential Pitfalls When Using Algorithms

The downside of using an algorithm to solve the problem is that this process tends to be very time-consuming.

So if you face a situation where a decision must be made very quickly, you might be better off using a different problem-solving strategy.

For example, an emergency room doctor making a decision about how to treat a patient could use an algorithm approach. However, this would be very time-consuming and treatment needs to be implemented quickly.

In this instance, the doctor would instead rely on their expertise and past experiences to very quickly choose what they feel is the right treatment approach.

Algorithms can sometimes be very complex and may only apply to specific situations. This can limit their use and make them less generalizable when working with larger populations.

Algorithms can be a great problem-solving choice when the answer needs to be 100% accurate or when each decision needs to follow the same process. A different approach might be needed if speed is the primary concern.

In psychology, algorithms are frequently contrasted with heuristics . Both can be useful when problem-solving, but it is important to understand the differences between them.

What Is a Heuristic?

A heuristic is a mental shortcut that allows people to quickly make judgments and solve problems.

These mental shortcuts are typically informed by our past experiences and allow us to act quickly. However, heuristics are really more of a rule-of-thumb; they don't always guarantee a correct solution.

So how do you determine when to use a heuristic and when to use an algorithm? When problem-solving, deciding which method to use depends on the need for either accuracy or speed.

When to Use an Algorithm

If complete accuracy is required, it is best to use an algorithm. By using an algorithm, accuracy is increased and potential mistakes are minimized.

If you are working in a situation where you absolutely need the correct or best possible answer, your best bet is to use an algorithm. When you are solving problems for your math homework, you don't want to risk your grade on a guess.

By following an algorithm, you can ensure that you will arrive at the correct answer to each problem.

When to Use a Heuristic

On the other hand, if time is an issue, then it may be best to use a heuristic. Mistakes may occur, but this approach allows for speedy decisions when time is of the essence.

Heuristics are more commonly used in everyday situations, such as figuring out the best route to get from point A to point B. While you could use an algorithm to map out every possible route and determine which one would be the fastest, that would be a very time-consuming process. Instead, your best option would be to use a route that you know has worked well in the past.

Psychologists who study problem-solving have described two main processes people utilize to reach conclusions: algorithms and heuristics. Knowing which approach to use is important because these two methods can vary in terms of speed and accuracy.

While each situation is unique, you may want to use an algorithm when being accurate is the primary concern. But if time is of the essence, then an algorithm is likely not the best choice.

Lang JM, Ford JD, Fitzgerald MM. An algorithm for determining use of trauma-focused cognitive-behavioral therapy . Psychotherapy (Chic) . 2010;47(4):554-69. doi:10.1037/a0021184

Stein DJ, Shoptaw SJ, Vigo DV, et al. Psychiatric diagnosis and treatment in the 21st century: paradigm shifts versus incremental integration . World Psychiatry . 2022;21(3):393-414. doi:10.1002/wps.20998

Bobadilla-Suarez S, Love BC. Fast or frugal, but not both: decision heuristics under time pressure . J Exp Psychol Learn Mem Cogn . 2018;44(1):24-33. doi:10.1037/xlm0000419

Giordano C, Brennan M, Mohamed B, Rashidi P, Modave F, Tighe P. Accessing artificial intelligence for clinical decision-making . Front Digit Health . 2021;3:645232. doi:10.3389/fdgth.2021.645232

By Kendra Cherry, MSEd Kendra Cherry, MS, is a psychosocial rehabilitation specialist, psychology educator, and author of the "Everything Psychology Book."

Help | Advanced Search

Computer Science > Cryptography and Security

Title: double index calculus algorithm: faster solving discrete logarithm problem in finite prime field.

Abstract: Solving the discrete logarithm problem in a finite prime field is an extremely important computing problem in modern cryptography. The hardness of solving the discrete logarithm problem in a finite prime field is the security foundation of numerous cryptography schemes. In this paper, we propose the double index calculus algorithm to solve the discrete logarithm problem in a finite prime field. Our algorithm is faster than the index calculus algorithm, which is the state-of-the-art algorithm for solving the discrete logarithm problem in a finite prime field. Empirical experiment results indicate that our algorithm could be more than a 30-fold increase in computing speed than the index calculus algorithm when the bit length of the order of prime field is 70 bits. In addition, our algorithm is more general than the index calculus algorithm. Specifically, when the base of the target discrete logarithm problem is not the multiplication generator, the index calculus algorithm may fail to solve the discrete logarithm problem while our algorithm still can work.

Subjects:	Cryptography and Security (cs.CR)
Cite as:	[cs.CR]
	(or [cs.CR] for this version)
	Focus to learn more arXiv-issued DOI via DataCite

Submission history

Access paper:.

HTML (experimental)
Other Formats

References & Citations

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 .

Solving numerical and engineering optimization problems using a dynamic dual-population differential evolution algorithm

Original Article
Published: 14 September 2024

Cite this article

Wenlu Zuo 1 , 2 &
Yuelin Gao ORCID: orcid.org/0000-0003-2021-2097 1 , 2

Differential evolution (DE) is a cutting-edge meta-heuristic algorithm known for its simplicity and low computational overhead. But the traditional DE cannot effectively balance between exploration and exploitation. To solve this problem, in this paper, a dynamic dual-population DE variant (ADPDE) is proposed. Firstly, the dynamic population division mechanism based on individual potential value is presented to divide the population into two subgroups, effectively improving the population diversity. Secondly, a nonlinear reduction mechanism is designed to dynamically adjust the size of potential subgroup to allocate computing resources reasonably. Thirdly, two unique mutation strategies are adopted for two subgroups respectively to better utilise the effective information of potential individuals and ensure fast convergence speed. Finally, adaptive parameter setting methods of two subgroups further achieve the balance between exploration and exploitation. The effectiveness of improved strategies is verified on 21 classical benchmark functions. Then, to verify the overall performance of ADPDE, it is compared with three standard DE algorithms, eight excellent DE variants and seven advanced evolutionary algorithms on CEC2013, CEC2017 and CEC2020 test suites, respectively, and the results show that ADPDE has higher accuracy and faster convergence speed. Furthermore, ADPDE is compared with eight well-known optimizers and CEC2020 winner algorithms on nine real-world engineering optimization problems, and the results indicate ADPDE has the development potential for constrained optimization problems as well.

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

Access this article

Subscribe and save.

Get 10 units per month
Download Article/Chapter or eBook
1 Unit = 1 Article or 1 Chapter
Cancel anytime

Price includes VAT (Russian Federation)

Instant access to the full article PDF.

Rent this article via DeepDyve

Institutional subscriptions

Developments and Design of Differential Evolution Algorithm for Non-linear/Non-convex Engineering Optimization

Solving Constrained Non-linear Integer and Mixed-Integer Global Optimization Problems Using Enhanced Directed Differential Evolution Algorithm

An efficient modified differential evolution algorithm for solving constrained non-linear integer and mixed-integer global optimization problems, explore related subjects.

Artificial Intelligence

Data availability

All the data in Sect. 6 are obtained under the same experimental setting. Then, the source code of CEC2013 test suite can be downloaded from https://github.com/P-N-Suganthan/CEC2013 . The source code of CEC2017 test suite can be downloaded from https://github.com/P-N-Suganthan/CEC2017-BoundContrained . The source code of CEC2020 test suite can be downloaded from https://github.com/P-N-Suganthan/2020-Bound-Constrained-Opt-Benchmark . The source code of the nine engineering problems can be downloaded in https://github.com/P-N-Suganthan/2020-RW-Constrained-Optimisation . We solemnly declare that all data in this paper is true and valid.

Hajipour V, Kheirkhah AS, Tavana M et al (2015) Novel Pareto-based meta-heuristics for solving multi-objective multi-item capacitated lot-sizing problems. Int J Adv Manuf Technol 80:31–45. https://doi.org/10.1007/s00170-015-6993-6

Article Google Scholar

Abdel-Basset M, Abdel-Fatah L, Sangaiah AK (2018) Chapter 10-metaheuristic algorithms: a comprehensive review in computational intelligence for multimedia big data on the cloud with engineering applications. https://doi.org/10.1016/B978-0-12-813314-9.00010-4

Ribagin S, Lyubenova V (2021) Metaheuristic algorithms: theory and applications. In: research in computer science in the Bulgarian academy of sciences, pp 385–419. https://doi.org/10.1007/978-3-030-72284-5_18

Sloss AN, Gustafson S (2019) evolutionary algorithms review. In: Genetic programming theory and practice XVII, 2020, pp 307–344. https://doi.org/10.1007/978-3-030-39958-0_16

Ahmad MF, Isa NAM, Lim WH et al (2022) Differential evolution: a recent review based on state-of-the-art works. Alex Eng J 61(5):3831–3872. https://doi.org/10.1016/j.aej.2021.09.013

Lambora A, Gupta K, Chopra K (2019) Genetic algorithm—a literature review. In 2019 international conference on machine learning, big data, cloud and parallel computing (COMITCon). IEEE, pp 380–384. https://doi.org/10.1109/COMITCon.2019.8862255

Mehr AD, Nourani V, Kahya E et al (2018) Genetic programming in water resources engineering: a state-of-the-art review. J Hydrol 566:643–667. https://doi.org/10.1016/j.jhydrol.2018.09.043

Storn R, Price K (1997) Differential evolution—a simple and efficient heuristic for global optimization over continuous spaces. J Glob Optim 11(4):341. https://doi.org/10.1023/A:1008202821328

Article MathSciNet Google Scholar

Simon D (2008) Biogeography-based optimization. IEEE Trans Evol Comput 12(6):702–713. https://doi.org/10.1109/TEVC.2008.919004

Montiel O, Castillo O, Melin P et al (2007) Human evolutionary model: a new approach to optimization. Inf Sci 177(10):2075–2098. https://doi.org/10.1016/j.ins.2006.09.012

Kennedy J, Eberhart R (1995) Particle swarm optimization. In: Proceedings of ICNN’95-international conference on neural networks, vol 4. IEEE, pp 1942–1948. https://doi.org/10.1109/ICNN.1995.488968

Mirjalili S, Mirjalili SM, Lewis A (2014) Grey wolf optimizer. Adv Eng Softw 69:46–61. https://doi.org/10.1016/j.advengsoft.2013.12.007

Mirjalili S, Lewis A (2016) The whale optimization algorithm. Adv Eng Softw 95:51–67. https://doi.org/10.1016/j.advengsoft.2016.01.008

Heidari AA, Mirjalili S, Faris H et al (2019) Harris hawks optimization: algorithm and applications. Future Gener Comput Syst 97:849–872. https://doi.org/10.1016/j.future.2019.02.028

HaDehghani M, Montazeri Z, Trojovská E et al (2023) Coati optimization algorithm: a new bio-inspired metaheuristic algorithm for solving optimization problems. Knowl-Based Syst 259:110011. https://doi.org/10.1016/j.knosys.2022.110011

Xue J, Shen B (2023) Dung beetle optimizer: a new meta-heuristic algorithm for global optimization. J Supercomput 79(7):7305–7336. https://doi.org/10.1007/s11227-022-04959-6

Maheri A, Jalili S, Hosseinzadeh Y et al (2021) A comprehensive survey on cultural algorithms. Swarm Evol Comput 62:100846. https://doi.org/10.1016/j.swevo.2021.100846

Geem ZW, Kim JH, Loganathan GV (2001) A new heuristic optimization algorithm: harmony search. Simulation 76(2):60–68. https://doi.org/10.1177/003754970107600201

Rao RV, Savsani VJ, Vakharia DP (2011) Teaching-learning-based optimization: a novel method for constrained mechanical design optimization problems. Comput Aided Des 43(3):303–315. https://doi.org/10.1016/j.cad.2010.12.015

Das B, Mukherjee V, Das D (2020) Student psychology based optimization algorithm: a new population based optimization algorithm for solving optimization problems. Adv Eng Softw 146:102804. https://doi.org/10.1016/j.advengsoft.2020.102804

Wagan AI, Shaikh MM (2020) A new metaheuristic optimization algorithm inspired by human dynasties with an application to the wind turbine micrositing problem. Appl Soft Comput 90:106176. https://doi.org/10.1016/j.asoc.2020.106176

Rashedi E, Nezamabadi-Pour H, Saryazdi S (2009) GSA: a gravitational search algorithm. Inf Sci 179(13):2232–2248. https://doi.org/10.1016/j.ins.2009.03.004

Patel VK, Savsani VJ (2015) Heat transfer search (HTS): a novel optimization algorithm. Inf Sci 324:217–246. https://doi.org/10.1016/j.ins.2015.06.044

Mirjalili S, Mirjalili SM, Hatamlou A (2016) Multi-verse optimizer: a nature-inspired algorithm for global optimization. Neural Comput Appl 27:495–513. https://doi.org/10.1007/s00521-015-1870-7

Yadav A (2019) AEFA: artificial electric field algorithm for global optimization. Swarm Evol Comput 48:93–108. https://doi.org/10.1016/j.swevo.2019.03.013

Su H, Zhao D, Heidari AA et al (2023) RIME: a physics-based optimization. Neurocomputing 532:183–214. https://doi.org/10.1016/j.neucom.2023.02.010

Pekár J, Čičková Z, Brezina I (2016) Portfolio performance measurement using differential evolution. CEJOR 24:421–433. https://doi.org/10.1007/s10100-015-0393-8

Kaur M, Kumar V, Li L (2019) Color image encryption approach based on memetic differential evolution. Neural Comput Appl 31:7975–7987. https://doi.org/10.1007/s00521-018-3642-7

Abderazek H, Yildiz AR, Sait SM (2019) Mechanical engineering design optimisation using novel adaptive differential evolution algorithm. Int J Veh Des 80(2–4):285–329. https://doi.org/10.1504/IJVD.2019.109873

Mahmoodjanloo M, Tavakkoli-Moghaddam R, Baboli A et al (2020) Flexible job shop scheduling problem with reconfigurable machine tools: an improved differential evolution algorithm. Appl Soft Comput 94:106416. https://doi.org/10.1016/j.asoc.2020.106416

Zhang Y, Gong D, Gao X et al (2020) Binary differential evolution with self-learning for multi-objective feature selection. Inf Sci 507:67–85. https://doi.org/10.1016/j.ins.2019.08.040

Reddy SS (2019) Optimal power flow using hybrid differential evolution and harmony search algorithm. Int J Mach Learn Cybern 10(5):1077–1091. https://doi.org/10.1007/s13042-018-0786-9

Chai X, Zheng Z, Xiao J et al (2022) Multi-strategy fusion differential evolution algorithm for UAV path planning in complex environment. Aerosp Sci Technol 121:107287. https://doi.org/10.1016/j.ast.2021.107287

Awad NH, Ali MZ, Suganthan PN (2017) Ensemble sinusoidal differential covariance matrix adaptation with Euclidean neighborhood for solving CEC2017 benchmark problems. In: 2017 IEEE congress on evolutionary computation (CEC). IEEE, pp 372–379. https://doi.org/10.1109/CEC.2017.7969336

Sallam KM, Elsayed SM, Chakrabortty RK et al (2020) Improved multi-operator differential evolution algorithm for solving unconstrained problems. In: IEEE congress on evolutionary computation (CEC). IEEE, pp 1–8. https://doi.org/10.1109/CEC48606.2020.9185577

Biswas S, Saha D, De S et al (2021) Improving differential evolution through Bayesian hyperparameter optimization. In: 2021 IEEE Congress on evolutionary computation (CEC). IEEE, pp 832–840. https://doi.org/10.1109/CEC45853.2021.9504792

Qin AK, Huang VL, Suganthan PN (2008) Differential evolution algorithm with strategy adaptation for global numerical optimization. IEEE Trans Evol Comput 13(2):398–417. https://doi.org/10.1109/TEVC.2008.927706

Draa A, Bouzoubia S, Boukhalfa I (2015) A sinusoidal differential evolution algorithm for numerical optimisation. Appl Soft Comput 27:99–126. https://doi.org/10.1016/j.asoc.2014.11.003

Hassan S, Hemeida AM, Alkhalaf S et al (2020) Multi-variant differential evolution algorithm for feature selection. Sci Rep 10(1):1–16. https://doi.org/10.1038/s41598-020-74228-0

Layeb A (2024) Differential evolution algorithms with novel mutations, adaptive parameters, and Weibull flight operator. Soft Comput. https://doi.org/10.1007/s00500-023-09561-3

Zhang J, Sanderson AC (2009) JADE: adaptive differential evolution with optional external archive. IEEE Trans Evol Comput 13(5):945–958. https://doi.org/10.1109/TEVC.2009.2014613

Tanabe R, Fukunaga A (2013) Success-history based parameter adaptation for differential evolution. In: IEEE congress on evolutionary computation. IEEE, pp 71–78. https://doi.org/10.1109/CEC.2013.6557555

Tanabe R, Fukunaga AS (2014) Improving the search performance of SHADE using linear population size reduction. In: 2014 IEEE congress on evolutionary computation (CEC). IEEE, pp 1658–1665. https://doi.org/10.1109/CEC.2014.6900380

Tian M, Gao X, Dai C (2017) Differential evolution with improved individual-based parameter setting and selection strategy. Appl Soft Comput 56:286–297. https://doi.org/10.1016/j.asoc.2017.03.010

Meng Z, Pan JS, Tseng KK (2019) PaDE: an enhanced differential evolution algorithm with novel control parameter adaptation schemes for numerical optimization. Knowl-Based Syst 168:80–99. https://doi.org/10.1016/j.knosys.2019.01.006

Sun G, Yang B, Yang Z et al (2020) An adaptive differential evolution with combined strategy for global numerical optimization. Soft Comput 24:6277–6296. https://doi.org/10.1007/s00500-019-03934-3

Gupta S, Su R (2022) An efficient differential evolution with fitness-based dynamic mutation strategy and control parameters. Knowl-Based Syst 251:109280. https://doi.org/10.1016/j.knosys.2022.109280

Meng Z, Song Z, Shao X et al (2023) FD-DE: differential evolution with fitness deviation based adaptation in parameter control. ISA Trans. https://doi.org/10.1016/j.isatra.2023.05.005

Song Y, Zhao G, Zhang B et al (2023) An enhanced distributed differential evolution algorithm for portfolio optimization problems. Eng Appl Artif Intell 121:106004. https://doi.org/10.1016/j.engappai.2023.106004

Das S, Abraham A, Chakraborty UK et al (2009) Differential evolution using a neighborhood-based mutation operator. IEEE Trans Evol Comput 13(3):526–553. https://doi.org/10.1109/TEVC.2008.2009457

Wang Y, Cai Z, Zhang Q (2011) Differential evolution with composite trial vector generation strategies and control parameters. IEEE Trans Evol Comput 15(1):55–66. https://doi.org/10.1109/TEVC.2010.2087271

Gong W, Cai Z (2013) Differential evolution with ranking-based mutation operators. IEEE Trans Cybern 43(6):2066–2081. https://doi.org/10.1109/TCYB.2013.2239988

Wang H, Rahnamayan S, Sun H et al (2013) Gaussian bare-bones differential evolution. IEEE Trans Cybern 43(2):634–647. https://doi.org/10.1109/TSMCB.2012.2213808

Peng H, Wu Z, Zhou X et al (2015) Bare-bones differential evolution algorithm based on trigonometry. J Comput Res Dev 52:2776. https://doi.org/10.7544/issn1000-1239.2015.20140230

Mohamed AW, Mohamed AK (2019) Adaptive guided differential evolution algorithm with novel mutation for numerical optimization. Int J Mach Learn Cybern 10:253–277. https://doi.org/10.1007/s13042-017-0711-7

Sun G, Lan Y, Zhao R (2019) Differential evolution with Gaussian mutation and dynamic parameter adjustment. Soft Comput 23:1615–1642. https://doi.org/10.1007/s00500-017-2885-z

Sun G, Xu G, Jiang N (2020) A simple differential evolution with time-varying strategy for continuous optimization. Soft Comput 24:2727–2747. https://doi.org/10.1007/s00500-019-04159-0

Xia X, Tong L, Zhang Y et al (2021) NFDDE: a novelty-hybrid-fitness driving differential evolution algorithm. Inf Sci 579:33–54. https://doi.org/10.1016/j.ins.2021.07.082

Yi W, Chen Y, Pei Z et al (2022) Adaptive differential evolution with ensembling operators for continuous optimization problems. Swarm Evol Comput 69:100994. https://doi.org/10.1016/j.swevo.2021.100994

Meng Z, Yang C (2022) Two-stage differential evolution with novel parameter control. Inf Sci 596:321–342. https://doi.org/10.1016/j.ins.2022.03.043

Chen B, Ouyang H, Li S et al (2024) Differential evolution algorithm with a complementary mutation strategy and data fusion-based parameter adaptation. Inf Sci 668:120522. https://doi.org/10.1016/j.ins.2024.120522

Awad NH, Ali MZ, Suganthan PN et al (2017) CADE: a hybridization of cultural algorithm and differential evolution for numerical optimization. Inf Sci 378:215–241. https://doi.org/10.1016/j.ins.2016.10.039

Chaudhary D, Tailor AK, Sharma VP et al (2019) HyGADE: hybrid of genetic algorithm and differential evolution algorithm. In: 2019 10th international conference on computing, communication and networking technologies (ICCCNT). IEEE, pp 1–4. https://doi.org/10.1109/ICCCNT45670.2019.8944822

Rosić MB, Simić MI, Pejović PV (2021) An improved adaptive hybrid firefly differential evolution algorithm for passive target localization. Soft Comput 25:5559–5585. https://doi.org/10.1007/s00500-020-05554-8

Pan Q, Tang J, Wang H et al (2022) SFSADE: an improved self-adaptive differential evolution algorithm with a shuffled frog-leaping strategy. Artif Intell Rev. https://doi.org/10.1007/s10462-021-10099-9

Li J, Gao Y, Zhang H et al (2022) Self-adaptive opposition-based differential evolution with subpopulation strategy for numerical and engineering optimization problems. Complex Intell Syst 8(3):2051–2089. https://doi.org/10.1007/s40747-022-00734-5

Lin M, Wang Z, Zheng W (2023) Hybrid particle swarm-differential evolution algorithm and its engineering applications. Soft Comput 27(22):16983–17010. https://doi.org/10.1007/s00500-023-09025-8

Zhong JH, Shen M, Zhang J et al (2012) A differential evolution algorithm with dual populations for solving periodic railway timetable scheduling problem. IEEE Trans Evol Comput 17(4):512–527. https://doi.org/10.1109/TEVC.2012.2206394

Zhan ZH, Liu XF, Zhang H et al (2016) Cloudde: a heterogeneous differential evolution algorithm and its distributed cloud version. IEEE Trans Parallel Distrib Syst 28(3):704–716. https://doi.org/10.1109/TPDS.2016.2597826

Wu G, Mallipeddi R, Suganthan PN et al (2016) Differential evolution with multi-population based ensemble of mutation strategies. Inf Sci 329:329–345. https://doi.org/10.1016/j.ins.2015.09.009

Civicioglu P, Besdok E, Gunen MA et al (2020) Weighted differential evolution algorithm for numerical function optimization: a comparative study with cuckoo search, artificial bee colony, adaptive differential evolution, and backtracking search optimization algorithms. Neural Comput Appl 32:3923–3937. https://doi.org/10.1007/s00521-018-3822-5

Zhu L, Ma Y, Bai Y (2020) A self-adaptive multi-population differential evolution algorithm. Nat Comput 19:211–235. https://doi.org/10.1007/s11047-019-09757-3

Zhong X, Cheng P (2021) An elite-guided hierarchical differential evolution algorithm. Appl Intell 51:4962–4983. https://doi.org/10.1007/s10489-020-02091-7

Deng L, Li C, Han R et al (2021) TPDE: a tri-population differential evolution based on zonal-constraint stepped division mechanism and multiple adaptive guided mutation strategies. Inf Sci 575:22–40. https://doi.org/10.1016/j.ins.2021.06.035

Deng Y, Chen D, Zou F et al (2022) Heterogeneous ensemble algorithms for function optimization. Appl Intell 52(11):13310–13338. https://doi.org/10.1007/s10489-022-03197-w

Huang Y, Qian X, Song W (2023) Improving dual-population differential evolution based on hierarchical mutation and selection strategy. Electronics 13(1):62. https://doi.org/10.3390/electronics13010062

Hussain K, Salleh MNM, Cheng S et al (2019) On the exploration and exploitation in popular swarm-based metaheuristic algorithms. Neural Comput Appl 31:7665–7683. https://doi.org/10.1007/s00521-018-3592-0

Morales-Castañeda B, Zaldivar D, Cuevas E et al (2020) A better balance in metaheuristic algorithms: does it exist? Swarm Evol Comput 54:100671. https://doi.org/10.1016/j.swevo.2020.100671

Das S, Mullick SS, Suganthan PN (2016) Recent advances in differential evolution-an updated survey. Swarm Evol Comput 27:1–30. https://doi.org/10.1016/j.swevo.2016.01.004

Pant M, Zaheer H, Garcia-Hernandez L et al (2020) Differential Evolution: a review of more than two decades of research. Eng Appl Artif Intell 90:103479. https://doi.org/10.1016/j.engappai.2020.103479

Kumar V, Kumar D (2021) A systematic review on firefly algorithm: past, present, and future. Arch Comput Methods Eng 28:3269–3291. https://doi.org/10.1007/s11831-020-09498-y

Eusuff MM, Lansey KE (2003) Optimization of water distribution network design using the shuffled frog leaping algorithm. J Water Resour Plan Manag 129(3):210–225. https://doi.org/10.1061/(ASCE)0733-9496(2003)129:3(210)

Ma H, Shen S, Yu M et al (2019) Multi-population techniques in nature inspired optimization algorithms: a comprehensive survey. Swarm Evol Comput 44:365–387. https://doi.org/10.1016/j.swevo.2018.04.011

Novoa-Hernández P, Corona CC, Pelta DA (2013) Self-adaptive, multipopulation differential evolution in dynamic environments. Soft Comput 17:1861–1881. https://doi.org/10.1007/s00500-013-1022-x

Bai X, Yan W, Ge SS et al (2018) An integrated multi-population genetic algorithm for multi-vehicle task assignment in a drift field. Inf Sci 453:227–238. https://doi.org/10.1016/j.ins.2018.04.044

Heidari AA, Chen H, Chen H et al (2020) Multi-population differential evolution-assisted Harris hawks optimization: framework and case studies. Future Gener Comput Syst 111:175–198. https://doi.org/10.1016/j.future.2020.04.008

Navarro MA, Oliva D, Ramos-Michel A et al (2022) An improved multi-population whale optimization algorithm. Int J Mach Learn Cybern 13(9):2447–2478. https://doi.org/10.1007/s13042-022-01537-3

Cao Y, Shi H, Chang DL (2022) Differential evolution algorithm with dynamic multi-population applied to flexible job shop schedule. Eng Optim 54(3):387–408. https://doi.org/10.1080/0305215X.2021.1872067

Tian L, Li Z, Yan X (2020) High-performance differential evolution algorithm guided by information from individuals with potential. Appl Soft Comput 95:106531. https://doi.org/10.1016/j.asoc.2020.106531

Zhang X, Wen S, Wang D (2022) Multi-population biogeography-based optimization algorithm and its application to image segmentation. Appl Soft Comput 124:109005. https://doi.org/10.1016/j.asoc.2022.109005

Liu Q, Pang T, Chen K et al (2022) Multi-subpopulation adaptive, based differential evolution for global optimization. In: 2022 IEEE congress on evolutionary computation (CEC). IEEE, pp 1–7. https://doi.org/10.1109/CEC55065.2022.9870398

Li C, Sun G, Deng L et al (2023) A population state evaluation-based improvement framework for differential evolution. Inf Sci 629:15–38. https://doi.org/10.1016/j.ins.2023.01.120

Das R, Das KN, Mallik S et al (2024) A novel self-adaptive multi-population quadratic approximation guided jaya for solving real-parameter constrained optimization problems. Expert Syst Appl 238:121898. https://doi.org/10.1016/j.eswa.2023.121898

Brest J, Zamuda A, Fister I et al (2010) Large scale global optimization using self-adaptive differential evolution algorithm. In: IEEE congress on evolutionary computation. IEEE, pp 1–8. https://doi.org/10.1016/j.eswa.2023.121898

Guan Y, Yang L, Sheng W (2017) Population control in evolutionary algorithms: review and comparison. In: Bio-inspired computing: theories and applications: 12th international conference, BIC-TA 2017, Harbin, December 1–3, Proceedings 12. Springer Singapore, pp 161–174. https://doi.org/10.1007/978-981-10-7179-9_13

Yan H, Zhu Y (2015) Bang-bang control model for uncertain switched systems. Appl Math Model 39(10–11):2994–3002. https://doi.org/10.1016/j.apm.2014.10.042

Tang L, Dong Y, Liu J (2014) Differential evolution with an individual-dependent mechanism. IEEE Trans Evol Comput 19(4):560–574. https://doi.org/10.1109/TEVC.2014.2360890

Wang J, Ouyang H, Zhang C et al (2023) A novel intelligent global harmony search algorithm based on improved search stability strategy. Sci Rep 13(1):7705. https://doi.org/10.1038/s41598-023-34736-1

Tian L, Li Z, Yan X (2020) Potential-based differential evolution algorithm with joint adaptation of parameters and strategies. IEEE Access 8:100562–100577. https://doi.org/10.1109/ACCESS.2020.2997355

Liang JJ, Qu BY, Suganthan PN et al (2013) Problem definitions and evaluation criteria for the CEC 2013 special session on real-parameter optimization. Zhengzhou University, Zhengzhou, China and Nanyang Technological University, Singapore, Technical Report, Computational Intelligence Laboratory

Awad N, Ali M, Liang J et al (2017) Problem definitions and evaluation criteria for the CEC 2017 special session and competition on singe objective bound constrained real-parameter numerical optimization. Technical report, Nanyang Technological University, Singapore

Yue CT, Price KV, Suganthan PN, Liang JJ, Ali MZ, Qu BY, Awad NH, Biswas PP (2019) Problem definitions and evaluation criteria for the CEC 2020 special session and competition on single objective bound constrained numerical optimization. Technical Report, Zhengzhou University and Nanyang Technological University

Derrac J, García S, Molina D et al (2011) A practical tutorial on the use of nonparametric statistical tests as a methodology for comparing evolutionary and swarm intelligence algorithms. Swarm Evol Comput 1(1):3–18. https://doi.org/10.1016/j.swevo.2011.02.002

Seyyedabbasi A, Kiani F (2022) Sand cat swarm optimization: a nature-inspired algorithm to solve global optimization problems. Eng Comput. https://doi.org/10.1007/s00366-022-01604-x

Hashim FA, Houssein EH, Hussain K et al (2022) Honey badger algorithm: new metaheuristic algorithm for solving optimization problems. Math Comput Simul 192:84–110. https://doi.org/10.1016/j.matcom.2021.08.013

Chopra NH, Ansari MM (2022) Golden jackal optimization: a novel nature-inspired optimizer for engineering applications. Expert Syst Appl 198:116924. https://doi.org/10.1016/j.eswa.2022.116924

Liu W, Wang Z, Yuan Y et al (2019) A novel sigmoid-function-based adaptive weighted particle swarm optimizer. IEEE Trans Cybern 51(2):1085–1093. https://doi.org/10.1109/TCYB.2019.2925015

Zhang Z, Gao Y, Liu Y et al (2023) A hybrid biogeography-based optimization algorithm to solve high-dimensional optimization problems and real-world engineering problems. Appl Soft Comput. https://doi.org/10.1016/j.asoc.2023.110514

Mirjalili S, Gandomi AH, Mirjalili SZ et al (2017) Salp swarm algorithm: a bio-inspired optimizer for engineering design problems. Adv Eng Softw 114:163–191. https://doi.org/10.1016/j.advengsoft.2017.07.002

Chou JS, Truong DN (2021) A novel metaheuristic optimizer inspired by behavior of jellyfish in ocean. Appl Math Comput 389:125535. https://doi.org/10.1016/j.amc.2020.125535

Abdollahzadeh B, Gharehchopogh FS, Mirjalili S (2021) African vultures optimization algorithm: a new nature-inspired metaheuristic algorithm for global optimization problems. Comput Ind Eng 158:107408. https://doi.org/10.1016/j.cie.2021.107408

Jia H, Peng X, Lang C (2021) Remora optimization algorithm. Expert Syst Appl 185:115665. https://doi.org/10.1016/j.eswa.2021.115665

Hashim FA, Hussien AG (2022) Snake optimizer: a novel meta-heuristic optimization algorithm. Knowl-Based Syst 242:108320. https://doi.org/10.1016/j.knosys.2022.108320

Zhong C, Li G, Meng Z (2022) Beluga whale optimization: a novel nature-inspired metaheuristic algorithm. Knowl-Based Syst. https://doi.org/10.1016/j.knosys.2022.109215

Azizi M, Talatahari S, Gandomi AH (2023) Fire hawk optimizer: a novel metaheuristic algorithm. Artif Intell Rev 56(1):287–363. https://doi.org/10.1007/s10462-022-10173-w

Wang L, Cao Q, Zhang Z et al (2022) Artificial rabbits optimization: a new bio-inspired meta-heuristic algorithm for solving engineering optimization problems. Eng Appl Artif Intell 114:105082. https://doi.org/10.1016/j.engappai.2022.105082

Coello CAC (2002) Theoretical and numerical constraint-handling techniques used with evolutionary algorithms: a survey of the state of the art. Comput Methods Appl Mech Eng 191(11–12):1245–1287. https://doi.org/10.1016/S0045-7825(01)00323-1

Download references

Acknowledgements

This work was supported by the Key Project of Ningxia Natural Science Foundation (2022AAC02043), the First-class Discipline Construction Fund Project of Ningxia Higher Education (NXYLXK2017B09), the Major Scientific Research Special of North Minzu University (ZDZX201901), the 2023 Graduate Innovation Project of North Minzu University (YCX23075) and the Basic Discipline Research Projects Supported by Nanjing Securities (NJZQJCXK202201).

Author information

Authors and affiliations.

School of Mathematics and Information Science, North Minzu University, Yinchuan, 750021, China

Wenlu Zuo & Yuelin Gao

Ningxia Province Key Laboratory of Intelligent Information and Data Processing, Yinchuan, 750021, China

You can also search for this author in PubMed Google Scholar

Contributions

Wenlu Zuo: investigation, methodology, experiment, writing: original draft, review and editing. Yuelin Gao: supervision, funding acquisition.

Corresponding author

Correspondence to Yuelin Gao .

Ethics declarations

Conflict of interest.

We declare that we have no financial interest or personal competition that could affect the work described herein. All of us authors guarantee that the paper is legitimate and entirely our own scientific research. No copying, plagiarism, infringement, data forgery and other bad behavior, no state secrets involved. The sources of other works cited in the manuscript are noted. We will be responsible for the financial losses and negative effects caused by our bad behavior.

Additional information

Publisher's note.

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

Appendix A: Mathematical models of nine engineering problems

1.1 a.1 pressure vessel design, 1.2 a.2 rolling element bearing design, 1.3 a.3 tension/compression spring design, 1.4 a.4 welded beam design, 1.5 a.5 multiple disk clutch brake design, 1.6 a.6 step-cone pulley problem, 1.7 a.7 speed reducer design, 1.8 a.8 planetary gear train design, 1.9 a.9 robot gripper problem, 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

Zuo, W., Gao, Y. Solving numerical and engineering optimization problems using a dynamic dual-population differential evolution algorithm. Int. J. Mach. Learn. & Cyber. (2024). https://doi.org/10.1007/s13042-024-02361-7

Download citation

Received : 01 September 2023

Accepted : 20 August 2024

Published : 14 September 2024

DOI : https://doi.org/10.1007/s13042-024-02361-7

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

Differential evolution
Dual-population
Individual potential value
Engineering optimization
Find a journal
Publish with us
Track your research

IMAGES

DAA 1 7 Fundamentals of Algorithmic problem solving
problem solving and algorithmic thinking
Algorithmic Problem Solving
Unit2 algorithmic problem_solving
What is Problem Solving Algorithm?, 4 Steps, Representation
PPT

VIDEO

Algorithmic Thinking and Problem Solving|CLASS 7 UNIT NO 3.3.1 |NBF& FG
GE 3151 -PSPP- Algorithmic problem solving techniques
L1
1.5 Algorithmic Problem Solving in Tamil
Fundamentals of Algorithmic problem Solving
FUNDAMENTALS OF ALGORITHMIC PROBLEM SOLVING

COMMENTS

How to Use Algorithms to Solve Problems?
End - End the execution. Let's take some examples of algorithms for computer science problems. Example 1. Swap two numbers with a third variable. Step 1: Start. Step 2: Take 2 numbers as input. Step 3: Declare another variable as "temp". Step 4: Store the first variable to "temp". Step 5: Store the second variable to the First variable.
How to use algorithms to solve everyday problems
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?"
Algorithms Tutorial
Algorithms Tutorial. Algorithm is a step-by-step procedure for solving a problem or accomplishing a task. In the context of data structures and algorithms, it is a set of well-defined instructions for performing a specific computational task. Algorithms are fundamental to computer science and play a very important role in designing efficient ...
Understanding Algorithms: The Key to Problem-Solving Mastery
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.
1.1: Activity 1
Algorithmic problem solving comes in two phases. These include: derivation of an algorithm that solves the problem, and; conversion of the algorithm into code. It is worth noting that: an algorithm is a sequence of steps, not a program.
Data Structures and Algorithms: 20 Problem-Solving Techniques
Understand what problem this algorithm or data structure is trying to solve: Here, learning where other alternatives fall short is helpful. Break it down to the key elements or steps that define the algorithm. Understand them individually and how they connect. From this, code the algorithm. Example 1: Binary search
What Is an Algorithm?
An algorithm is a sequence of instructions that a computer must perform to solve a well-defined problem. It essentially defines what the computer needs to do and how to do it. Algorithms can instruct a computer how to perform a calculation, process data, or make a decision. The best way to understand an algorithm is to think of it as a recipe ...
What is Problem Solving Algorithm?, 4 Steps, Representation
Flowchart. 1. A method of representing the step-by-step logical procedure for solving a problem. Flowchart is diagrammatic representation of an algorithm. It is constructed using different types of boxes and symbols. 2. It contains step-by-step English descriptions, each step representing a particular operation leading to solution of problem.
Fundamentals of Algorithmic Problem Solving
An input to an algorithm specifies an instance of the problem the algorithm solves. It is very important to specify exactly the set of instances the algorithm needs to handle. (As an example, recall the variations in the set of instances for the three greatest common divisor algorithms discussed in the previous section.)
What is Algorithm
Greedy algorithm and divide and conquer algorithm are two common algorithmic paradigms used to solve problems. The main difference between them lies in their approach to solving problems. Greedy Algorithm:The greedy algorithm is an algorithmic paradigm that follows the problem-solving heuristic of making the locally optimal choice at each stage wit
Problem Solving with Algorithms and Data Structures using Python
An interactive version of Problem Solving with Algorithms and Data Structures using Python. ... Dijkstra's Algorithm; 7.21. Analysis of Dijkstra's Algorithm; 7.22. Prim's Spanning Tree Algorithm; 7.23. Summary; 7.24. Key Terms; 7.25. Discussion Questions; 7.26. Programming Exercises;
Problem Solving with Algorithms and Data Structures using Python
Problem Solving with Algorithms and Data Structures using Python¶. By Brad Miller and David Ranum, Luther College. Assignments; There is a wonderful collection of YouTube videos recorded by Gerry Jenkins to support all of the chapters in this text.
Algorithmic Problem Solving[Book]
Title: Algorithmic Problem Solving. Author (s): Release date: December 2011. Publisher (s): Wiley. ISBN: 9780470684535. An entertaining and captivating way to learn the fundamentals of using algorithms to solve problems The algorithmic approach to solving problems in computer technology is an essential tool. With this ….
4. Problem Solving and Algorithms
The development of an algorithm (a plan) is a key step in solving a problem. Once we have an algorithm, we can translate it into a computer program in some programming language. Our algorithm development process consists of five major steps. Step 1: Obtain a description of the problem. Step 2: Analyze the problem.
1: Algorithmic Problem Solving
1.1: Activity 1 - Introduction to Algorithms and Problem Solving. In this learning activity section, the learner will be introduced to algorithms and how to write algorithms to solve tasks faced by learners or everyday problems. Examples of the algorithm are also provided with a specific application to everyday problems that the learner is ...
Problem Solving and Algorithmic Thinking
Preamble. Algorithmic Thinkingis a fundamental skill in this 21st Century. This course provides the foundations of Computational Problem Solving. It focuses on principles and methods rather than on systems and tools thus providing transferable skills to any other domain. It also provides foundation for developing computational perspectives of ...
Problem-Solving Strategies: Definition and 5 Techniques to Try
An algorithm is a step-by-step problem-solving strategy based on a formula guaranteed to give you positive results. For example, you might use an algorithm to determine how much food is needed to ...
How to develop an Algorithm from Scratch
Developing Algorithmic Thinking via Practicing Steps of Problem-Solving: Understand the problem statement, and identify inputs, and desired output. Break down the problem into smaller subproblems to handle complexity. Determine the logic needed to solve each subproblem efficiently. Combine the solutions of subproblems to solve the main problem.
8.2 Problem-Solving: Heuristics and Algorithms
Algorithms. In contrast to heuristics, which can be thought of as problem-solving strategies based on educated guesses, algorithms are problem-solving strategies that use rules. Algorithms are generally a logical set of steps that, if applied correctly, should be accurate. For example, you could make a cake using heuristics — relying on your ...
Algorithms
If this problem persists, tell us. Our mission is to provide a free, world-class education to anyone, anywhere. Khan Academy is a 501(c)(3) nonprofit organization. Donate or volunteer today! Site Navigation. About. News; Impact; Our team; Our interns; Our content specialists; Our leadership; Our supporters; Our contributors; Our finances; Careers;
The Algorithm Problem Solving Approach in Psychology
When solving a problem, choosing the right approach is often the key to arriving at the best solution.In psychology, one of these problem-solving approaches is known as an algorithm. While often thought of purely as a mathematical term, the same type of process can be followed in psychology to find the correct answer when solving a problem or making a decision.
Khan Academy
Discover the basic elements of algorithms and how to combine them to solve problems. Khan Academy offers free, interactive lessons on computer science theory.
Double Index Calculus Algorithm: Faster Solving Discrete Logarithm
Solving the discrete logarithm problem in a finite prime field is an extremely important computing problem in modern cryptography. The hardness of solving the discrete logarithm problem in a finite prime field is the security foundation of numerous cryptography schemes. In this paper, we propose the double index calculus algorithm to solve the discrete logarithm problem in a finite prime field ...
Solving numerical and engineering optimization problems ...
Differential evolution (DE) is a cutting-edge meta-heuristic algorithm known for its simplicity and low computational overhead. But the traditional DE cannot effectively balance between exploration and exploitation. To solve this problem, in this paper, a dynamic dual-population DE variant (ADPDE) is proposed. Firstly, the dynamic population division mechanism based on individual potential ...

Which program is right for you?

Executive Programs

How to use algorithms to solve everyday problems

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

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

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

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

What are the secret ingredients of a successful Facebook post?

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

Which companies use algorithms well?

Related Articles

Exploring the Intricacies of NP-Completeness in Computer Science

Understanding Algorithms: The Key to Problem-Solving Mastery

What are Algorithms?

The Importance of Algorithms

Common Types of Algorithms: Searching and Sorting

Diving Deeper: Graph and Dynamic Programming Algorithms

Recursion: A Powerful Technique

Related Articles

Three Elegant Algorithms Every Computer Science Beginner Should Know

Have a language expert improve your writing

What Is an Algorithm? | Definition & Examples

Instantly correct all language mistakes in your text

Table of contents

Don't submit your assignments before you do this

Cite this Scribbr article

Is this article helpful?

Kassiani Nikolopoulou

What is Problem Solving Algorithm?, Steps, Representation

Definition of Problem Solving Algorithm

Steps for Problem Solving

Analysing the Problem

Developing an Algorithm

Testing and Debugging

Representation of Algorithms

Advantages of Flowcharts:

Pseudo code

Advantages of Pseudocode

Chapter: Introduction to the Design and Analysis of Algorithms

Problem Solving with Algorithms and Data Structures using Python ¶

Acknowledgements ¶

Indices and tables ¶

Problem Solving with Algorithms and Data Structures using Python ¶

Acknowledgements ¶

Indices and tables ¶

Algorithmic Problem Solving

Book description

Table of contents

Product information

You might also like

Difficult Conversations

Problem Solving

Generative AI in the Real World: Putting AI in the Hands of Farmers with Rikin Gandhi

Don’t leave empty-handed

It’s yours, free.

Check it out now on O’Reilly

Problem Solving and Algorithms

Problems, Solutions, and Tools

An Algorithm Development Process

Step 1: Obtain a description of the problem.

Example 4.1: Pick and Plant

Problem Statement (Step 1)

Analysis of the Problem (Step 2)

High-level Algorithm (Step 3)

Detailed Algorithm (Step 4)

Review the Algorithm (Step 5)

Java Code for "Pick and Plant"

FIRST BUILD

SECOND BUILD

THIRD BUILD

FOURTH BUILD (final)

Java Code for "Replace Net with Flower"

How to develop an Algorithm from Scratch | Develop Algorithmic Thinking

Developing Algorithmic Thinking via Solving Puzzles:

Developing Algorithmic Thinking via Practicing Steps of Problem-Solving:

How to solve a problem using Algorithmic Thinking:

Benefits of Algorithmic Thinking:

Thought of Optimization in Algorithmic Thinking:

Algorithmic Thinking via Understanding Real-life Applications:

Conclusion: