Algorithm Flowchart
Pseudocode Written description
Program code Sequence
Selection Iteration

 

A graphical representation of an algorithm, showing the steps as boxes of various kinds, and their order by connecting them with arrows. A step-by-step procedure for solving a problem or achieving a specific goal.
A textual explanation of an algorithm, using natural language and/or mathematical notation. An informal high-level description of the operating principle of a computer program or other algorithm.
An ordered list of instructions that must be executed one after the other in a specific order. Instructions written by a programmer in a programming language, describing the specific steps to be executed by a computer in order to perform a certain task.
Repeating a set of instructions multiple times, either a specific number of times or until a condition is met. A branch in an algorithm that depends on a condition being true or false, and that selects one of two or more paths to follow accordingly.

 

While loop For loop
Nested loop Debugging
Algorithm Flowchart
Pseudocode Written Description

 

A loop that is repeated for a specific number of times, depending on the value of a counter variable. A loop that continues to execute as long as a certain condition is true.
The process of identifying and fixing errors or problems in a program or algorithm. A loop that is contained within another loop, and that executes its instructions multiple times for each iteration of the outer loop.
A graphical representation of an algorithm, using various shapes and arrows to illustrate the steps involved. A set of instructions that solve a problem or performs a task.
A text-based representation of an algorithm, describing the necessary steps in detail. A high-level description of an algorithm that combines elements of a programming language with plain English.

 

Program Code Input
Output Control Structures
Iteration Selection
Variable Data Structure

 

Data that is received by an algorithm. The actual code written in a programming language to implement an algorithm.
Statements that allow a programmer to direct the flow of an algorithm, such as loops and conditionals. The result produced by an algorithm.
Choosing a specific set of instructions to execute in an algorithm based on certain conditions. Repeating a set of instructions multiple times in an algorithm.
A way of organizing and storing data in an algorithm, such as arrays, lists, and trees. A named location in memory used to store a value that may change during the execution of an algorithm.

 

Algorithm Purpose
Function Steps
Identify Explain
Workings Task

 

The reason or intention for which something is done or created or for which something exists. A set of instructions designed to accomplish a specific task or solve a particular problem.
Individual instructions that make up an algorithm. The purpose that something is created or designed for.
To make something clear or easy to understand. To recognize or distinguish something from others.
A piece of work to be done or undertaken. The operational details or mechanisms of an algorithm.

 

Problem Input
Output Iteration
Syntax error Logic error
Trace table Error message

 

Data or information given to an algorithm. An inquiry starting from given conditions to investigate or demonstrate a fact, result, or law.
The process of repeating a set of instructions multiple times with different inputs or variables. Result produced by an algorithm after processing input.
A mistake in the way that a program or algorithm works that produces incorrect results. A mistake in the way that code is written that prevents it from running correctly.
Information output by a computer program in response to a problem or error. A tool used to track the values of variables as a program or algorithm runs.

 

Debugging Variable
Flowchart Breakpoint
Runtime error Step-through
Debugging tool Compile error

 

A named container in a program that holds a value. The process of identifying and correcting errors in a computer program or algorithm.
A point in a program where the execution can be paused for debugging purposes. A diagram that represents the steps and decisions in a process or program.
A method of debugging that involves moving through a program or algorithm one step at a time. A mistake in the way that a program or algorithm runs that causes it to crash or terminate unexpectedly.
A mistake in the way that code is written that prevents it from being converted into an executable program. Any tool or feature that aids in the process of identifying and correcting errors in a computer program or algorithm.

 

high-level programming languages algorithm
coding syntax
variables statements
loops conditionals

 

A set of instructions that specify a sequence of steps to solve a particular problem or perform a task in a high-level programming language. A type of programming language that is designed to be easier for humans to read and write, often using English-like syntax.
The set of rules that dictate how a programming language must be written, including punctuation, keywords, and other elements of the language's structure. The process of writing instructions in a high-level programming language that can be executed by a computer.
A single instruction or command in a program written in a high-level programming language. A symbolic name that represents a value that can change during the execution of a program in a high-level programming language.
A control structure that allows a program to make decisions based on a particular condition in a high-level programming language. A control structure that repeats a specific set of instructions in a program until a certain condition is met in a high-level programming language.

 

arrays functions
parameters return
Algorithm Design Sequence
Selection Iteration

 

A self-contained block of code that performs a specific task, which can be called from anywhere in a program written in a high-level programming language. A data structure that stores a collection of elements, which can be of any type, in a particular order in a program written in a high-level programming language.
A statement that specifies the value that a function should produce as output in a program written in a high-level programming language. A value that is passed into a function when it is called, allowing the function to handle different inputs in a high-level programming language.
A programming construct that defines a set of instructions that must be executed in a particular order. The process of designing a set of instructions (algorithm) to solve a specific problem in a logical and efficient manner.
A programming construct that enables the repetition of a set of instructions, either for a certain number of times or until a certain condition is met. A programming construct that defines a decision-making process to determine which set of instructions should be executed based on a certain condition.

 

Flowcharts Pseudocode
Written Descriptions Draft Program Code
Control Structures Conditional Statements
Loop Structures Counter-Controlled Loop

 

A way of expressing an algorithm using a mixture of natural language and simple code-like syntax. A graphical representation of an algorithm that uses specific symbols and arrows to illustrate the flow of instructions.
An initial version of the program code that includes the main structure and the main instructions to be followed. A textual representation of an algorithm that uses a structured and concise language to describe the set of instructions that must be followed.
Programming constructs used to perform different actions based on a specific condition, such as if-else statements and switch statements. Programming constructs used to control the flow of instructions in a program, such as if statements, for loops, and while loops.
A loop structure that repeats a set of instructions a predetermined number of times, based on the value of a counter variable. Programming constructs used to repeat a set of instructions for a certain number of times or until a certain condition is met, such as for loops and while loops.

 

algorithm output determining
correct output data sets
practice input data
evaluate function

 

The process of figuring out or calculating the output of an algorithm for a specific set of input data. The desired result or output of an algorithm when given certain input data.
A collection of related data points, often used to test or evaluate the effectiveness of an algorithm. The accurate or expected result produced by an algorithm when given certain input data.
The information or variables given to an algorithm to produce an output. Repeating the process of determining the output of an algorithm for various sets of input data to improve understanding and accuracy.
A set of instructions or operations that take input data and produce a desired output result. Judging or assessing the effectiveness or accuracy of an algorithm's output based on the input data.

 

variable algorithm
output instruction
Bubble sort Merge sort
Linear search Binary search

 

A set of instructions or operations that can accomplish a specific task or solve a problem. A value or symbol that can change or be assigned a new value during the execution of an algorithm.
A specific command or operation given to an algorithm to perform a task or process input data. The result or solution produced by an algorithm when given certain input data.
A sorting algorithm that divides the input array into halves, sorts each of those halves, and then merges them back together. A sorting algorithm that repeatedly swaps adjacent elements if they are in the wrong order.
A search algorithm that repeatedly divides the search interval in half until the target value is found or the search interval is empty. A search algorithm that sequentially checks each element in a list until a match is found or the whole list has been searched.

 

Algorithm Comparison
Swapping Sorting
Divide and conquer Search
Efficiency Recursive function

 

The act of comparing two or more things to determine their similarities or differences. A step-by-step procedure for solving a problem or accomplishing a task.
The process of arranging data in a particular order, usually in ascending or descending order. The act of exchanging the positions of two elements in an array or list.
The process of looking for a specific item in a list or array. A problem-solving strategy where a large problem is broken down into smaller, more manageable problems that are solved independently and then combined to solve the larger problem.
A function that calls itself within its own definition, either directly or indirectly. The measure of how quickly an algorithm can solve a problem, usually measured in terms of time or space complexity.

 

Algorithm Data structures
Efficiency Selection sort
Bubble sort Insertion sort
Merge sort Quick sort

 

A way of organizing and storing data in a computer program so that it can be accessed and used efficiently. A set of instructions designed to solve a specific problem or perform a specific task in a finite amount of time.
A sorting algorithm that sorts an array by repeatedly finding the minimum element from the unsorted part and putting it at the beginning. The ability of an algorithm to use as few resources as possible to accomplish a task or solve a problem.
A sorting algorithm that builds the final sorted array one item at a time by inserting each new item into its proper place. A simple sorting algorithm that repeatedly steps through the list, compares adjacent elements and swaps them if they are in the wrong order.
A sorting algorithm that picks an element as a pivot and partitions the array around the pivot, recursively sorting the two sub-arrays. A sorting algorithm that sorts an array by dividing it into two halves, sorting the two halves separately, and then merging the sorted halves.

 

Data values Scenario
Recommendation Algorithm choice
Fitness for Purpose Evaluating
Logical Reasoning Test Data

 

A situation or problem that requires a solution, often involving a specific set of data values. Values that are used as input to algorithms or stored in data structures.
The process of selecting the most appropriate algorithm for solving a particular problem based on the available data and efficiency considerations. A suggestion or advice given based on knowledge and expertise, often involving the appropriate algorithm choice.
The process of assessing and analyzing the fitness for purpose of an algorithm. The extent to which an algorithm meets its intended requirements and objectives.
Data used for evaluating the fitness for purpose of an algorithm, typically representing a range of possible input values and edge cases. The ability to think and reason logically to evaluate the effectiveness of an algorithm.

 

Algorithm Requirements
Objective Analysis
Assessment Input Values
Edge Cases Pseudocode

 

The intended objectives and constraints that an algorithm is designed to meet. A sequence of steps or instructions for solving a problem or performing a specific task, often expressed in pseudocode or a programming language.
The process of breaking down a complex problem into smaller parts to better understand and evaluate its effectiveness. Clearly defined goals that an algorithm is intended to achieve.
The data or variables that are provided as input to an algorithm for computation or processing. The process of evaluating the fitness for purpose of an algorithm by measuring its performance against defined criteria.
A high-level, informal description of an algorithm, often used for planning and design purposes. Test cases that examine extreme or unusual input values that may not be typical or common.

 

Problem Decomposition Importance
Problem-Solving Sub-Problems
Simplification Decomposition Strategy
Algorithm Design Modular Programming

 

The importance of problem decomposition lies in its ability to simplify complex problems, making them easier to solve. Problem decomposition is the process of breaking down a complex problem into smaller, more manageable sub-problems in order to simplify the problem-solving process.
Sub-problems are smaller, more manageable problems that arise from breaking down a complex problem using problem decomposition. Problem-solving is the process of finding solutions to difficult or complex issues.
Decomposition strategy is a problem-solving approach that involves breaking down a complex problem into smaller sub-problems in order to solve them more easily. Simplification is the process of making something easier to understand or solve.
Modular programming is a programming technique that involves breaking down a program into smaller, independent modules that can be tested and maintained separately. Algorithm design is the process of creating a step-by-step set of instructions for solving a problem.

 

Abstraction Top-Down Design
Bottom-Up Design Hierarchical Structure
Problem Analysis Problem Requirements
Solution Design Algorithm

 

Top-down design is a problem-solving approach that involves starting with the big picture and breaking it down into smaller, more manageable pieces. Abstraction is a problem-solving technique that involves focusing on the essential aspects of a problem and ignoring irrelevant details.
A hierarchical structure is a system of organization that involves dividing a problem into sub-problems, each of which can be further divided into smaller sub-problems. Bottom-up design is a problem-solving approach that involves starting with the details and building up to the big picture.
The specific needs and constraints of a problem that must be met in order to develop a solution The process of examining a problem in order to understand it better, identify the requirements and constraints, and develop an appropriate solution
A set of instructions for carrying out a specific task or solving a specific problem The process of creating a plan or strategy to solve a problem based on the requirements and constraints identified in the problem analysis phase

 

Flowchart Pseudo-code
Abstraction Modularity
Top-down approach Bottom-up approach
Iteration Testing

 

A simplified, high-level description of a computer program that uses a combination of natural language and programming constructs to describe the steps involved A graphical representation of the steps and decisions involved in a process or algorithm
The practice of breaking a complex problem or system down into smaller, more manageable components or modules that can be developed and tested independently The process of simplifying a complex system or problem by focusing only on the most important details and ignoring the rest
A problem-solving approach that begins with the individual tasks and then builds them up into larger and larger components until the overall structure is identified A problem-solving approach that begins with the overall structure and then breaks it down into smaller and smaller components until the individual tasks are identified
The process of evaluating a solution in order to identify and fix any errors or problems The process of repeating a set of steps or actions multiple times in order to refine or improve a solution

 

Abstraction Modelling
Real World Process
Simplification Data Abstraction
Entity Attribute

 

Creating an abstract representation of a real-world system or process in order to better understand and solve problems related to it. The process of removing unnecessary detail, while preserving the relevant and essential characteristics to create a simplified representation of a system or process.
A sequence of steps taken to achieve a particular goal, often involving inputs, outputs, and transformations of data and information. The physical, non-virtual world that surrounds us, and which we seek to represent in computational models.
A technique for representing complex data structures in a simpler, more organized way, by focusing on their essential properties and ignoring irrelevant detail. The act of reducing the complexity and number of details associated with a system or process, in order to make it easier to understand and work with.
A characteristic or property of an entity, which we wish to represent in a computational model using abstraction. An object or concept that exists in the real world, and which we wish to represent in a computational model using abstraction.

 

Class Inheritance
Encapsulation Interface
Programming Abstractions Classes
Functions Data Structures

 

A mechanism in which one class inherits the attributes and behavior of another, allowing us to represent variations and hierarchies of entities in a computational model using abstraction. A blueprint or template for creating objects of a certain type, which we use to represent entities in a computational model using abstraction.
The set of public methods and properties that define how an object can be interacted with, without revealing its implementation details. The practice of hiding implementation details of an object so that users of the object only need to know its abstract interface.
A class is a blueprint or template for creating objects in an object-oriented programming language. Programming abstractions are techniques used to simplify complex programming problems by using abstract representations to represent common features of the problem.
A data structure is a way of organizing and storing data in a computer so that it can be accessed and modified efficiently. A function is a self-contained block of code that performs a specific task and returns a result.

 

Object-oriented Programming Abstraction
Inheritance Encapsulation
Polymorphism Modularity
Function Overloading Function Templates

 

Abstraction is the process of reducing complexity by hiding unnecessary details while highlighting relevant ones. Object-oriented programming is a programming paradigm that uses objects to represent and manipulate data and behavior.
Encapsulation is the practice of hiding the internal details of an object from the outside world, while providing a public interface for interacting with it. Inheritance is a mechanism in object-oriented programming that allows a new class to be based on an existing class, inheriting its methods and properties.
Modularity is the practice of breaking a program down into smaller, more manageable pieces, or modules, that can be independently developed, tested, and maintained. Polymorphism is the ability of an object to take on many forms, depending on the context in which it is used.
Function templates are a mechanism in C++ that allow the creation of generic functions that can work with many different data types. Function overloading is the process of defining multiple functions with the same name but with different parameters.

 

Problem Decomposition Abstraction
Modularization Top-Down Design
Bottom-Up Design Divide and Conquer
Recursion Algorithm

 

The process of focusing on the important information and ignoring irrelevant details. The process of breaking down a large and complex problem into smaller, more manageable sub-problems that are easier to solve.
A problem-solving approach that starts with a high-level view of the problem and gradually breaks it down into smaller and more manageable sub-problems. The process of dividing a system into smaller, independent components or modules that can be developed and tested separately.
A problem-solving approach that involves dividing a problem into smaller and more manageable sub-problems, solving each sub-problem separately, and then combining the solutions to solve the original problem. A problem-solving approach that starts with small and simple sub-problems and gradually builds them up into a complete solution.
A step-by-step procedure for solving a problem or achieving a specific goal. A problem-solving technique that involves solving a problem by breaking it down into smaller instances of the same problem until a base case is reached.

 

Pseudocode Flowchart
Debugging Testing

 

A graphical representation of the steps involved in solving a problem or achieving a specific goal, using symbols and arrows to indicate the flow of control. A high-level description of the steps involved in solving a problem or achieving a specific goal, using a combination of natural language and programming-like syntax.
The process of running a program or system to identify errors or problems and ensure that it meets its specified requirements. The process of identifying and correcting errors or bugs in a program.