Scribd
Upload
7 views

Algorithm Instructions

The document discusses important rules for designing algorithms such as correctness, clarity, efficiency, generality, robustness, modularity, scalability, readability, testing, and documentation. It then provides an example algorithm to find the maximum element in an array and explains how it follows these principles.

Uploaded by

Shatanik Chakraborty
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
7 views

Algorithm Instructions

The document discusses important rules for designing algorithms such as correctness, clarity, efficiency, generality, robustness, modularity, scalability, readability, testing, and documentation. It then provides an example algorithm to find the maximum element in an array and explains how it follows these principles.

Uploaded by

Shatanik Chakraborty
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 2

INTRODUCTION TO ALGORITHM WRITING

(By Prof. Shatanik Chakraborty, Dept. of CSE, MSIT)

When designing algorithms, adherence to certain rules or principles can contribute to the
clarity, efficiency, and reliability of the algorithm. Here are some important algorithm rules:

1. Correctness: The algorithm must produce the correct output for all possible inputs within
its specified domain. This includes handling edge cases and unexpected inputs appropriately.
2. Clarity: The algorithm should be easy to understand and follow by both the algorithm
designer and other developers who may need to maintain or use it in the future. Use descriptive
variable names, comments, and clear logic to enhance clarity.
3. Efficiency: Strive to design algorithms that are efficient in terms of time and space
complexity. Choose appropriate data structures and algorithms to minimize resource usage and
execution time.
4. Generality: Design algorithms that are generalizable and applicable to a wide range of input
scenarios. Avoid overly specific solutions that only work for a narrow set of inputs.
5. Robustness: Ensure that the algorithm can handle unexpected or erroneous inputs gracefully,
without crashing or producing incorrect results. Implement error checking and validation
mechanisms as needed.
6. Modularity: Divide complex algorithms into smaller, modular components or functions.
This promotes code reuse, simplifies debugging, and improves maintainability.
7. Scalability: Consider the scalability of the algorithm with respect to input size. Ensure that
the algorithm performs well even as the size of the input data increases.
8. Readability: Write the algorithm in a clear and readable manner, following consistent
indentation and formatting conventions. This makes the code easier to understand and debug.
9. Testing: Thoroughly test the algorithm with a variety of input data, including boundary cases
and edge cases, to ensure correctness and robustness. Use both automated tests and manual
inspection as appropriate.
10. Documentation: Provide comprehensive documentation for the algorithm, including its
purpose, inputs, outputs, usage instructions, and any assumptions or limitations. This helps
users understand how to use the algorithm correctly.
Let's consider an example algorithm for finding the maximum element in an array of integers.
Here's a simple algorithm written in pseudocode:

Algorithm: FindMaximum
Input: An array of integers, arr, of length n
Output: The maximum element in arr

Step-1: Set max_element to the first element of arr


Step-2: Iterate for each element in arr starting from the second
element
Step-2.1: Check if the current element is greater than max_element
Step-2.1.1: If true, set max_element to the current element
Step-3: Return max_element as the maximum element in arr

Now, let's break down this algorithm:

Input: The input to this algorithm is an array of integers, arr, with n elements.
Output: The output is the maximum element found in the array arr.
Initialization (Step 1): We initialize a variable max_element to store the maximum element
found so far. We start by assuming that the first element of the array is the maximum.
Iteration (Step 2): We iterate over each element of the array, starting from the second element
(since we already initialized max_element with the first element).
If the current element being examined is greater than max_element, we update max_element
to be the current element.
Return (Step 3): Once we have iterated over all elements, we return max_element as the
maximum element found in the array.

You might also like