Comprehensive Study Guide: Algorithms and Flowcharts

Definition: An algorithm is defined as a finite set of clear, unambiguous, and ordered steps designed to solve a specific problem.
Core Functions:
- Specifies WHAT actions must be performed.
- Dictates IN WHAT ORDER those actions must be executed.
Representations:
- Algorithms can be expressed in simple English prose, pseudocode, or other structured formatting styles.
- Programming languages serve to translate these algorithmic solutions into directly executable machine/computer code.
Characteristics of a Good Algorithm:
- Input: Accepts zero or more clearly defined input values.
- Output: Produces at least one output result.
- Definiteness: Every individual step must be clear, precise, and unambiguous in meaning.
- Finiteness: The algorithm must terminate after executing a finite number of steps.
- Effectiveness: Every step must be basic enough to be feasibly executed in practice.
- Correctness: Consistently yields the correct and intended output for valid inputs.
Example: Add Two Numbers
- Problem Statement: Read two numbers and display their sum.
- Algorithm Steps:
1. Start
2. Read $A$ and $B$
3. Calculate $SUM = A + B$
4. Display $SUM$
5. Stop

Definition: A flowchart is a visual or graphical representation of an algorithm.
Core Characteristics and Benefits:
- Utilizes standardized geometric symbols interconnected by directional flow arrows.
- Simplifies the visual comprehension, analysis, and discussion of program logic.
- Serves as a fundamental tool for program planning, instruction, debugging, and comprehensive documentation.
Basic Diagrammatic Connection:
- Illustrates sequential control handoff between phases, such as moving from a terminal Start state to an Input block.
Standard Flowchart Symbols:
- Oval: Represents Terminal points (Start / End / Stop).
- Rectangle: Represents Process / Calculation operations.
- Parallelogram: Represents Input / Output operations.
- Diamond: Represents Decision nodes (evaluating conditional branches).
- Arrows / Lines: Indicate the direction of execution flow.

Overview: Complex software systems and algorithms are synthesized by combining three primary structural patterns:
- Sequence: Instructions are executed sequentially, one after another.
- Selection: Decision criteria branch execution into alternative paths.
- Iteration (Repetition): A specific sequence of steps is repeatedly executed as long as a condition is satisfied.

Definition: Execution flows linearly in a continuous line from start to finish without conditional branches or repeating loops.
Sequence Example 1: Add Two Numbers and Print Sum
- Logic Flow:
- Start
- Input numbers: $a, b$
- Calculate $Sum = a + b$
- Display $Sum$
- Stop
Sequence Example 2: Find Percentage of Five Subject Marks
- Logic Flow:
- Start (START)
- Input subject marks: $S_1, S_2, S_3, S_4, S_5$
- Calculate total marks: $Total = S_1 + S_2 + S_3 + S_4 + S_5$
- Calculate percentage: $Percentage = Total % 5$
- Display output: $Total\text{ Marks}$ & $Percentage$
- Stop (STOP)

Definition: Implements choice and conditional logic (such as IF-ELSE structures) where decision nodes direct the flow down distinct operational branches.
Selection Example: Determine if Given Number $N$ is Positive or Negative
- Logic Flow:
- Start (START)
- Input value $N$
- Decision node: Check if $N > 0$
  - Yes Path: Execute process Positive
  - No Path: Execute process Negative
- End state (END)

Definition: Continuously repeats a block of instructions while a controlling boolean condition remains true.
Common Code Implementations: FOR loops, WHILE loops, and DO-WHILE loops.
Iteration Example 1: Print Numbers from 1 to 10
- Textual Algorithm Steps:
- Step 1: Start
- Step 2: Initialize loop variable $i$ to $1$
- Step 3: Repeat while $i \le 10$
  - a. Print the value of $i$
  - b. Increment $i$ by $1$ ( $i = i + 1$
- Step 4: End
- Flowchart Logic:
- Start (Start)
- Process node: Initialize counter variable $c = 1$
- Decision node: Evaluate is $c < 11$ ?
  - Yes Path:
  - Output node: Print $c$
  - Process node: Increment $c = c + 1$
  - Loop back to decision node is $c < 11$
  - No Path:
  - Terminal node: Stop
Iteration Example 2: Print Sum of Numbers from 1 to $N$
- Flowchart Logic:
- Start (START)
- Input node: READ $N$
- Initialization process node: $SUM = 0$ , $COUNT = 1$
- Loop processes:
  - $SUM = SUM + COUNT$
  - $COUNT = COUNT + 1$
- Decision node: Evaluate IS $COUNT > N$ ?
  - NO Path: Re-entry loop back to $SUM = SUM + COUNT$
  - YES Path: Proceed to output
- Output node: OUTPUT $SUM$
- Terminal node: STOP W
  Comparative Analysis: Algorithm vs. Flowchart

Algorithm:
- Formatted as plain text.
- Quick and simple to write initially.
- Expressed through written statements and numbered steps.
- Ideal for describing fine-grained, detailed logic.
Flowchart:
- Formatted graphically.
- Highly effective for visual logic tracking.
- Expressed through standard geometric symbols and connecting lines.
- Ideal for gaining a comprehensive overview of program architecture and control flow.

Worked Example 1: Adding Three Numbers
- Logic Steps:
- START
- Input node: READ $A, B, C$
- Process node: $S = A + B + C$
- Output node: OUTPUT $S$
- STOP
Worked Example 2: Find the Larger of Two Numbers
- Logic Steps:
- START
- Input node: READ $X, Y$
- Decision node: Evaluate IS $X > Y$ ?
  - YES Branch: Output node OUTPUT $X$ $\rightarrow$ STOP
  - NO Branch: Output node OUTPUT $Y$ $\rightarrow$ STOP

Problem 1: Write an algorithm to calculate the area of a rectangle.
Problem 2: Draw a flowchart to check whether a given number is positive, negative, or zero.
Problem 3: Write an algorithm to find the average of three numbers.
Problem 4: Draw a flowchart to display numbers in descending order from $10$ down to $1$
Challenge Problem: Construct an algorithm and corresponding flowchart to find the largest among three numbers.