Algorithms, Flowcharts & Logical Thinking

Computational Thinking is a structured problem-solving methodology that breaks down complex challenges into manageable steps that a human or computer can execute effectively.

The Four Pillars of Computational Thinking

1. Decomposition: Breaking a large, overwhelming problem into smaller, bite-sized, manageable sub-problems (e.g., to build a video game, you break it down into character graphics, score tracking, physics collision, and audio sound effects).
2. Pattern Recognition: Observing similarities, patterns, and trends among problems (e.g., recognizing that calculating the area of 50 different bedrooms uses the exact same formula: $\text{Length} \times \text{Breadth}$).
3. Abstraction: Filtering out unnecessary background details to focus exclusively on essential information (e.g., a metro train map ignores real-world street curves, buildings, and trees, showing only station stops and track connections).
4. Algorithm Design: Creating an ordered, step-by-step set of precise instructions to solve the problem systematically.

An Algorithm is a finite sequence of well-defined, unambiguous, step-by-step instructions designed to accomplish a specific task or solve a computational problem.

Five Non-Negotiable Properties of a Valid Algorithm

• 1. Unambiguous (Definiteness): Every step must be crystal clear with strictly one interpretation. Vague instructions like "add some sugar" or "wait a while" are invalid.
• 2. Finiteness: The algorithm must terminate after a finite number of steps. An infinite loop that runs forever is an algorithm failure.
• 3. Well-Defined Inputs: The algorithm specifies zero or more clearly defined inputs provided from the outside.
• 4. Definite Outputs: The algorithm must produce at least one meaningful, verified output result.
• 5. Feasibility (Effectiveness): Every step must be basic enough to be carried out in practice using finite resources and time.

Classic Algorithm Example: Finding the Larger of Two Numbers

Step 1: START
Step 2: INPUT two numbers into variables A and B
Step 3: IF A > B THEN
            PRINT "A is greater"
        ELSE IF B > A THEN
            PRINT "B is greater"
        ELSE
            PRINT "Both numbers are equal"
        END IF
Step 4: STOP

A Flowchart is a pictorial or graphical diagrammatic representation of an algorithm. It uses standard geometric symbols connected by directional flow arrows to map the path of data execution.

Standard ANSI Flowchart Symbols

Every computer algorithm in existence—from a pocket calculator to an artificial intelligence engine—is assembled from just three core building blocks:

1. Sequence Structure

Steps are executed one after another in a linear, continuous sequence without any branching or jumping. (e.g., Start -> Input A, B -> Sum = A + B -> Print Sum -> Stop).

2. Selection / Branching Structure (Conditional)

The program encounters a decision diamond with a condition. Based on whether the condition evaluates to True or False, execution branches down one of two alternative paths.

• IF (Score ≥ 40) THEN Print "Pass" ELSE Print "Fail"

3. Iteration / Looping Structure (Repetition)

A sequence of steps is repeated multiple times until a specified exit condition is fulfilled. Looping eliminates repetitive code.

• Counter-Controlled Loop: Repeats a fixed number of times (e.g., "Print numbers from 1 to 10").
• Condition-Controlled Loop: Repeats as long as a condition holds true (e.g., "Keep playing music WHILE battery > 5%").

A Trace Table (Dry Run) is a manual paper-and-pencil diagnostic technique used by programmers to test an algorithm by tracking the step-by-step changes in variable values without running it on a computer.

Trace Table Walkthrough: Sum of First 3 Natural Numbers

Algorithm Logic: Sum = 0; N = 1; WHILE N ≤ 3 DO: Sum = Sum + N; N = N + 1; END WHILE; Print Sum