Introduction to Algorithms

An algorithm is a procedure used for solving a problem or performing a computation. Algorithms act as an exact list of instructions that conduct specified actions step by step in either hardware- or software-based routines.
Algorithms are widely used throughout all areas of IT. In mathematics and computer science, an algorithm usually refers to a small procedure that solves a recurrent problem. Algorithms are also used as specifications for performing data processing and play a major role in automated systems.
An algorithm could be used for sorting sets of numbers or for more complicated tasks, like recommending user content on social media. Algorithms typically start with initial input and instructions that describe a specific computation. When the computation is executed, the process produces an output.

The Core Blueprint of an Algorithm

Every algorithm, no matter how simple or complex, follows a basic four-step structure:

Input: The algorithm receives data. This could be a list of numbers, a text search, or a swipe on a smartphone screen.
Processing: The algorithm executes its pre-defined, step-by-step rules on that data. This involves math, logic, and decision-making.
Output: The final result is produced. This could be a sorted list, a search result, or a recommended video.
Control/Looping (Optional): Many algorithms repeat steps until a specific condition is met (e.g., "repeat this step until the entire list is in alphabetical order").

The Three Building Blocks

Computer scientists build algorithms using three basic control structures:

Sequence: Running steps in a specific, linear order (Step A -> Step B -> Step C).
Selection (Conditionals): Making decisions based on a condition. These are If-Then-Else statements. For example: If the password is correct, log the user in; Else, show an error message.
Iteration (Loops): Repeating a set of steps until a task is done. For example: While there are unread emails in the inbox, update the unread notification count.

There are several types of algorithms, all designed to accomplish different tasks. For example, algorithms perform the following:

Search engine algorithm. This algorithm takes search stringsof keywords and operators as input, searches its associated database for relevant webpages and returns results.

Encryption algorithm. This computing algorithm transforms data according to specified actions to protect it. A symmetric key algorithm, such as the Data Encryption Standard, for example, uses the same keyto encrypt and decrypt data. As long as the algorithm is sufficiently sophisticated, no one lacking the key can decrypt the data.

Greedy algorithm. This algorithm solves optimization problems by finding the locally optimal solution, hoping it is the optimal solution at the global level. However, it does not guarantee the most optimal solution.

Recursive algorithm. This algorithm calls itself repeatedly until it solves a problem. Recursive algorithms call themselves with a smaller value every time a recursive function is invoked.

Backtracking algorithm. This algorithm finds a solution to a given problem in incremental approaches and solves it one piece at a time.

Divide-and-conquer algorithm. This common algorithm is divided into two parts. One part divides a problem into smaller subproblems. The second part solves these problems and then combines them together to produce a solution.

Dynamic programming algorithm. This algorithm solves problems by dividing them into subproblems. The results are then stored to be applied for future corresponding problems.

Brute-force algorithm. This algorithm iterates all possible solutions to a problem blindly, searching for one or more solutions to a function.

Sorting algorithm. Sorting algorithms are used to rearrange data structure based on a comparison operator, which is used to decide a new order for data.

Hashing algorithm. This algorithm takes data and converts it into a uniform message with a hashing

Randomized algorithm. This algorithm reduces running times and time-based complexities. It uses random elements as part of its logic.

Representing an algorithm

When it comes to representing an algorithm, you are essentially translating a conceptual solution into a structured, readable format before writing the actual code. Think of it as the blueprint for your software.

Depending on who you are sharing it with (a computer scientist, a client, or just your future self), there are four primary ways to represent an algorithm.

1. Natural Language (Plain English)

This is the most basic representation. You simply write out the steps in your native language.

Best for: High-level conceptual discussions with non-technical stakeholders.
Pros: Easy to write; requires no specialized knowledge.
Cons: Can be ambiguous, wordy, and easily misunderstood.

Example : The program starts by asking the user to type in their name. Once the user types it, the program saves that name so it can remember it. It then greets the user by saying "Hello" followed by their name, and immediately asks them how old they are. After the user types in their age, the program saves that number too. Finally, it checks the age: if the user is 70 years old or older, it tells them, "You are aged to perfection!" Otherwise, if they are under 70, it tells them, "You are a spring chicken!"

2. Pseudocode

Pseudocode is a detailed, step-by-step description of an algorithm written in a mixture of natural language and simplified programming constructs (like loops and conditionals). It has no strict syntax rules.

Best for: Bridging the gap between human thought and actual code.
Pros: Language-agnostic (works whether you plan to code in Python, Java, or C++); highly readable.
Cons: Lacks standardization; cannot be executed by a computer.

OUTPUT 'What is your name?'

INPUT user inputs their name

STORE the user's input in the name variable

OUTPUT 'Hello' + name OUTPUT 'How old are you?'

INPUT user inputs their age STORE the user's input in the age variable

IF age >= 70 THEN

OUTPUT 'You are aged to perfection!'

ELSE

OUTPUT 'You are a spring chicken!'

3. Flowcharts

A flowchart is a visual representation of an algorithm using standard geometric shapes connected by arrows (flowlines) to show the sequence of operations.

Key Flowchart Symbols:

4. Programming Code (Implementation)

This is the final, formal representation where the algorithm is translated into a specific programming language syntax so a computer can execute it.

Best for: Actual deployment and execution.
Pros: Precise, unambiguous, and machine-readable.
Cons: Requires knowledge of specific language syntax; harder for non-programmers to parse.

# Python implementation

# Ask the user for their name and store it in the 'name' variable

name = input("What is your name? ")

# Greet the user and ask for their age

print("Hello " + name)

age_input = input("How old are you? ")

# Convert the age input from text to a number for comparison

age = int(age_input)

# Check the age condition and output the appropriate message

if age >= 70:

print("You are aged to perfection!")

else:

print("You are a spring chicken!")

Some algorithms for practice

Write an algorithm which controls a pump which fills water into a tank.
Write an algorithm for a count down timer.
Write an algorithm which picks a bus rote with the shortest travel time.
Write an algorithm which allows you automate the process of making a cake.
Write an algorithm which allows you to find the number of occurences of a word in a paragraph.
Write an algorithm which allows you to monitor the fuel consumption of a vehicle.

Page updated

Google Sites

Report abuse