REVIEWER AL101.pdf

# Pseudocode ## What is Pseudocode? - An English-like representation of the required code for an algorithm or program code. - It is part English, part structured code. - **English Part:** provides a relaxed syntax that is easy to read. - **Code Part:** consists of an extended version of the...

# Pseudocode ## What is Pseudocode? - An English-like representation of the required code for an algorithm or program code. - It is part English, part structured code. - **English Part:** provides a relaxed syntax that is easy to read. - **Code Part:** consists of an extended version of the basic algorithmic constructs. - One of the most common tools for defining algorithms. ## Pseudocode Example ``` Algorithm AddArray(A,n): Purpose: Algorithm that displays the sum of even and odd numbers in an Array Input: An array A with n integer elements Output: The sum of n elements in A 1 index <- 0 2 sumEven <- 0 3 sumOdd <- 0 4 loop (index < n) 1 if (a[index] is even) 1 sumEven <- sumEven + A[index] 2 else 1 sumOdd <- sumOdd + A[index] 3 index <- index + 1 5 endloop 6 print sumEven, sumOdd ``` ## Parts of the Pseudocode - **Algorithm Header:** The title of the pseudocode that provides an overview of what it does. - **Statement Numbers:** Helps with readability and referencing specific steps, especially in more complex algorithms. - **Variables:** Placeholders for the data your algorithm works with. - **Statement Constructs:** Building blocks of your pseudocode that structure the logic. ## Variable Naming Rules 1. **Do not use single character names.** - Avoid the use of x, y, i, j and other letters of the alphabet in variable names. 2. **Do not use generic names.** - Examples of generic names are count, sum, total, row, column, and file. - Add an intelligent qualifier. For example: `studentCount`, `numberOfStudents`. 3. **Avoid the use of abbreviations.** - Use only intelligent abbreviations. For example, `studentCount` -> `stuCnt`; `numberOfStudents` -> `numOfStu`. ## Variables Example ``` Algorithm AddArray(A <array>,n <integer>): Purpose: Algorithm that displays the sum of even and odd numbers in an Array Input: An array A with n integer elements Output: The sum of n elements in A 1 index <integer> <- 0 2 sumEven <integer> <- 0 3 sumOdd <integer> <- 0 4 loop (index < n) 1 if (a[index] is even) 1 sumEven <- sumEven + A[index] 2 else 1 sumOdd <- sumOdd + A[index] 3 index <- index + 1 5 endloop 6 print sumEven, sumOdd ``` ## Why Is Statement Construct Important? - Using the right statement construct ensures your algorithm's logic is clear and correct. - This is crucial for writing algorithms that solve problems efficiently and accurately. ## Loops Statement Construct - Loops allow you to repeat a set of actions multiple times. - This is useful when you want to perform the same operation on each item in a list or continue doing something until a certain condition is met. - Iterates a block of code. ### Types of Loops - **Pre-test:** The condition is tested before the loop starts. The loop may not run at all if the condition is false. - Condition will be evaluated first. - If condition is true, the body is executed. - Otherwise, it terminates. - **Post-test:** The condition is tested after the loop has run once. The loop always runs at least one time. - Executes the statements in the body. - Condition is evaluated last. - If the condition is true, the body is re-executed. Otherwise, it terminates. ## Selection Statement Construct - Selection statements allow you to choose between different actions based on a condition. - This works like making decisions within your algorithm. - Statements that evaluate one or more alternatives. - If the alternatives are true, one path is taken. - If the alternatives are false, a different path is taken. ### Types of Selection - **2-way:** `if (condition) action1 else action2 endif` - **Multi-way:** - `if (condition1) action` - `elseif (condition2) action2` - ... - `elseif (conditionN) actionN` - `else actionN+1` - `endif` ## Sequence Statement Construct - A series of statements that do not alter the execution path within an algorithm. - The simplest type of statement construct. - Actions are performed one after another in a specific order. ### Example of Sequence - **Assignments**: `X <- X + 1` - **Operations**: `Y - 2` - **Algorithm Call**: `Sqrt(2); print "Hello"` ## Types of Statement Construct - **Sequence** - Assignments - Operation - Algorithm Call - **Selection** - 2-way - Multi-way - **Loop** - Pre-test - Post-test ## Statement Construct - Statement construct refers to the way you organize and structure the actions or steps in your pseudocode. - This is how you build the logical flow of your algorithm using different types of statements. # Algorithm ## Characteristics of an Algorithm - An algorithm is a step-by-step procedure or set of rules designed to perform a specific task or solve a particular problem. - **Key Characteristics of an Algorithm:** - **Well-defined input and output:** The algorithm must have a well-defined set of inputs and provide a clear and well-defined output. - **Finiteness:** The algorithm must terminate after a finite number of steps; it should not go into an infinite loop or run indefinitely. - **Definiteness (unambiguity):** Each step of the algorithm must be precisely defined and unambiguous. The actions to be performed must be clear and lead to a single, determined result. - **Effectiveness:** The steps of an algorithm must be basic enough to be carried out (in theory) by a person using only pencil and paper. Operations should be simple, unambiguous, and doable. - **Correctness:** An algorithm must produce the correct output for all possible inputs within its defined domain. - **Generality:** An algorithm should be applicable to a wide range of problems or inputs, not just a specific case. - **Efficiency:** An algorithm should be efficient in terms of time and space; it should perform the required task in the least amount of time and using the least amount of memory resources. - **Language independence:** An algorithm can be implemented in any programming language, and the logic of the algorithm remains the same irrespective of the language used. ## Algorithm Header ``` Algorithm AddArray(A <array>,n <integer>): Purpose: Algorithm that displays the sum of even and odd numbers in an Array Input: An array A with n integer elements Output: The sum of n elements in A ``` - **Components:** - **Name of algorithm:** Descriptive name of the algorithm. - **Parameters:** The input data that the algorithm will use. - **Purpose:** A short statement about what the algorithm does. - **Input Condition:** Precursor requirements for the parameters. - **Output Condition:** Identifies any action taken and the status of any output parameters. It also identifies the value returned by the algorithm. ## Problem Development Steps ### Mini Calculator #### Problem Definition: 1. **Objective:** Create a mini calculator that can perform basic arithmetic operations: addition, subtraction, multiplication, and division. 2. **Requirements:** - The calculator should handle two operands. - It should allow the user to select the operation. - The calculator should display the result of the operation. 3. **Constraints:** - Operands should be numeric (integers or floating-point numbers). - Division by zero should be handled gracefully with an error message. #### Algorithm Design 1. **Choose a Strategy:** - Simple Sequential Algorithm: Since the operations are straightforward and independent, a simple sequential approach is sufficient. 2. **Develop a Solution:** - **Pseudocode:** ``` Start Read the first number (operand1) Read the second number (operand2) Read the operator If operator is '+': result = operand1 + operand2 If operator is '-': result = operand1 - operand2 If operator is '*': result = operand1 * operand2 If operator is '/': Check if operand2 is not 0: If not 0, result = operand1 / operand2 Else, Display "Error: Division by Zero" Display the result End ``` #### Analysis 1. **Decomposition:** - **Input:** Two numbers (operands) and an operator (+, -, *, /). - **Process:** Perform the chosen arithmetic operation on the operands. - **Output:** The result of the operation. 2. **Feasibility:** The problem is straightforward and can be solved within typical constraints. Input validation and handling edge cases (like division by zero) are necessary. #### Implementation 1. **Programming Language:** Python is a good choice for this implementation due to its simplicity and built-in support for arithmetic operations. 2. **Code Structure:** Implement the code in a simple, modular way with functions for each operation and input validation. #### Optimization 1. **Time Complexity:** The time complexity of this algorithm is O(1) since each operation is performed in constant time. 2. **Space Complexity:** The space complexity is also O(1) as it only uses a fixed amount of space for variables. 3. **Optimization Techniques:** Since the problem is simple and the operations are efficient, no further optimization is needed. #### Debugging 1. **Error Identification:** - Ensure proper handling of invalid operators. - Check for type errors when nonnumeric inputs are provided. - Verify that division by zero is handled correctly 2. **Step through Debugging:** - Use Python's interactive debugger (`pdb`) or print statements to trace through the program if any unexpected results are encountered. 3. **Revisiting Design:** If errors are found, revisit the pseudocode and logic to ensure that edge cases are properly handled. #### Testing 1. **Test Cases:** Create a variety of test cases, including typical cases, edge cases, and boundary conditions: - **Typical Cases:** Test basic operations with positive numbers, negative numbers, and decimals. - **Edge Cases:** Test division by zero, very large numbers, very small numbers, and invalid inputs (e.g., nonnumeric inputs, invalid operators). 2. **Example Test Cases:** - Input: `"operand1 = 5", "operand2 = 3", "operator = +"`. Expected Output: `"8"` - Input: `"operand1 = 5", "operand2 = 0", "operator = /"`. Expected Output: `"Error: Division by zero"` - Input: `"operand1 = 7", "operand2 = 3", "operator = -"`. Expected Output: `"21"` - Input: `"operand1 = 2.5", "operand2 = 0.5", "operator = /"`. Expected output: `"5"` #### Documentation 1. **Code Comments:** Add comments to the code explaining each function's purpose and the overall flow of the program. 2. **Algorithm Description:** Write a brief document explaining how the mini calculator works, including assumptions (e.g., operands are numeric) and constraints (e.g., division by zero handling) 3. **Input/Output Specification:** Document the expected format of inputs and outputs, and describe how errors are handled. 4. **Complexity Analysis:** Note the complexity of the program. #### Maintenance 1. **Adaptation to New Requirements:** As requirements evolve, the algorithm might need to be updated to accommodate new features or changes. 2. **Bug Fixes:** New cases or bugs might be discovered that require revisiting the algorithm. 3. **Performance Enhancements:** As technology and tools evolve, there might be opportunities to improve the algorithm's performance. 4. **Documentation Updates:** Ensure that any changes are reflected in the documentation to avoid confusion in the future. ## Analysis - Break down the problem into smaller, manageable parts. - Identify the inputs, outputs, and the relationship between them. ### Steps - **Decomposition:** Divide the problem into smaller, more manageable components. This helps in understanding the problem from different angles. - **Input/output Identification:** Identify what data (input) will be provided and what results (output) are expected. Understanding the relationship between input and output is crucial. - **Feasibility:** Analyze whether the problem can be solved within the given constraints (time, resources, etc.). ## Pre-test **Instructions:** Answer a question that is assigned to you! **Questions** 1. What is an algorithm? 2. How do we go about designing an algorithm? 3. Why do we have to analyze the algorithm? 4. Create a flowchart for the mini calculator using the following task on the right: ``` Start Input Operand1 Input Operand2 Input Operator Decision on Operator - Addition: Operand1 + Operand2 - Subtraction: Operand1 - Operand2 - Multiplication: Operand1 * Operand2 - Division: Check if Operand2 is not 0: If not 0, Operand1 / Operand2 Else, Display "Error: Division by Zero" Display Result End ```