Chapter 6 — Flow Of Control

What is indentation? Indentation is the horizontal spacing (leading spaces or tabs) at the start of a line that visually and/or syntactically groups statements. In some languages (notably Python) indentation is part of the syntax and determines program structure. In other languages (C, C++, Java) indentation is only for readability while braces { } or keywords mark blocks.

What is a block? A block (or compound statement) is a group of one or more statements treated as a single unit. Blocks define scope: variables declared inside a block are local to that block and nested blocks. Blocks can be created by indentation (Python) or explicit delimiters like { } (C/C++/Java) or begin/end (Pascal).

Why it matters:

• Syntax: In Python, incorrect indentation causes IndentationError or changes program behaviour.
• Readability: Consistent indentation makes code easy to follow.
• Scope & lifetime: Blocks control which variables are visible where and for how long.

Rules and behaviour (concise):

• Python: all statements in the same block must have the same indentation level. A new block increases indentation (usually by 4 spaces); leaving the block decreases indentation.
• Brace languages: a pair of { ... } defines a block; indentation is a style convention but does not change meaning.
• Scope rule: a variable declared inside block B is visible in B and any blocks nested within B, but not visible in the outer block that contains B.
• Best practice: use 4 spaces per indent level and do not mix tabs and spaces.

Common errors:

• Python: inconsistent use of tabs and spaces, unexpected indent, or unindent does not match any outer indentation level.
• Brace languages: missing or mismatched braces leads to logic or compile errors; bad indentation hides such mistakes.

Short examples (illustrative):

# Python: indentation defines blocks
def greet(name):
    if name:
        for ch in name:
            print(ch)
    else:
        print('No name')

// C++ style: braces define blocks; indentation is for readability
void greet(string name) {
    if (name.length() > 0) {
        for (char c : name) {
            cout << c;
        }
    } else {
        cout << "No name";
    }
}

Scope example (concept): A variable declared inside an if-block is not accessible after the block ends:

if (cond):            # Python
    x = 5
# x is not defined here if x was meant to be inside a narrower scope

{
    int x = 5;         // C/C++
}
// x is not available here

Understanding indentation and block structure helps you write correct, readable programs and reason about where variables live and how control flows through nested statements.

Overview
Relational and logical operators are used in programming to compare values and combine boolean expressions. They are essential in flow control (if, while, for) to decide which path the program should take.

Relational operators
Relational operators compare two operands and return a boolean result (True/False). Common relational operators (used in Python/C/Java style) are:

• < : less than
• > : greater than
• <= : less than or equal to
• >= : greater than or equal to
• == : equal to (in many languages)
• != or <> : not equal to

Example: 5 < 8 is True; 10 == 3 is False.

Logical operators
Logical operators combine boolean expressions (results of relational operators or other boolean values). The main logical operators are:

• AND (in Python: and; in C/Java: &&) — True only if both operands are True.
• OR (in Python: or; in C/Java: ||) — True if at least one operand is True.
• NOT (in Python: not; in C/Java: !) — Inverts the boolean value.

Truth tables

AND:

OR:

NOT:

Precedence and short-circuit
Relational operators are evaluated before logical operators. Among logical operators, NOT has highest precedence, then AND, then OR. Short-circuit evaluation means evaluation stops as soon as the result is determined: in A AND B, if A is False, B is not evaluated; in A OR B, if A is True, B is not evaluated.

De Morgan's laws (useful for simplifying conditions)

• NOT (A AND B) = (NOT A) OR (NOT B)
• NOT (A OR B) = (NOT A) AND (NOT B)

Using these in flow control (example in Python-style pseudocode)

age = 18
has_id = True
if age >= 18 and has_id:
    print('Allowed to enter')
else:
    print('Not allowed')

Here, age >= 18 is a relational test; it combines with has_id using logical AND.

Tips for students

• Always check the precedence (use parentheses to make intention clear).
• Be careful with equality vs assignment operators in some languages (== vs =).
• Use De Morgan's laws to simplify or invert complex conditions.

Definition: Conditional statements (decision statements) control the flow of execution by running different blocks of code when given conditions are true or false. They let a program choose between alternatives based on boolean expressions (true/false).

Basic idea: Evaluate a condition (boolean expression). If it is true, execute one block; otherwise, skip it or execute an alternative block.

Common forms:

• Single if — run a block only when condition is true.
• If-else — choose between two blocks depending on condition.
• If-else if (ladder) — test several mutually exclusive conditions in order.
• Nested if — an if (or if-else) inside another if to check sub-conditions.
• Ternary (conditional) operator — short inline if-else available in many languages: result = condition ? valueIfTrue : valueIfFalse.
• Switch/case — select a branch based on the value of an expression (useful for many discrete cases).

Generic pseudocode syntaxes:

// single if
if condition then
    statements
end if

// if-else
if condition then
    statements_when_true
else
    statements_when_false
end if

// else-if ladder
if cond1 then
    s1
else if cond2 then
    s2
else
    s3
end if

// nested
if cond1 then
    if cond2 then
        s_inner
    end if
end if

// ternary (in many languages)
result = condition ? valueIfTrue : valueIfFalse

Boolean expressions and operators: Conditions are built using relational operators (==, !=, <, >, <=, >=) and logical operators (AND, OR, NOT). Precedence and short-circuit evaluation affect how compound conditions are computed.

Important concepts:

• Short-circuit evaluation: In expressions like A AND B, if A is false then B is not evaluated; in A OR B, if A is true then B is not evaluated.
• Order of tests: In an else-if ladder, tests are checked top to bottom — put more likely or more specific conditions first.
• Mutual exclusivity: For correct behavior use mutually exclusive ranges to avoid multiple matches in ladder checks.
• Common errors: Using assignment instead of comparison, wrong operator precedence, off-by-one in range checks, unreachable branches.

When to use what:

• Use single if for optional actions.
• Use if-else when there are two clear alternatives.
• Use else-if ladder or switch/case for many discrete alternatives.
• Use nested if to test dependent conditions (but avoid deep nesting — refactor into functions).

Complexity: Conditional checks are O(1) time each; overall decision logic complexity depends on the number of sequential checks in ladders (O(n) checks in worst-case).

Looping constructs let a program repeat a block of statements until a condition changes. They avoid code duplication and express repetition clearly. Each loop normally has three parts: initialization (set loop variables), condition (test to continue), and update (change variables so loop will eventually stop).

Types of loops

For-loop (count-controlled): used when the number of iterations is known or countable. Typical structure (pseudocode):

for i = start to end step step:
    statements

While-loop (entry-controlled): condition is checked before each iteration. Good when the number of iterations depends on runtime data.

while condition:
    statements
    update

Do-while loop (exit-controlled): body executes at least once because condition is checked after the body.

do {
    statements
    update
} while (condition);

Loop-control statements

break: immediately exit the loop. continue: skip the rest of the current iteration and proceed to the next. (In some languages 'pass' is a no-op.)

Nested loops and invariants

Loops can be placed inside other loops (nested). Total iterations multiply (outer_times * inner_times). A loop invariant is a condition that remains true before and after each iteration; it helps prove correctness.

Common issues

Infinite loops (update missing or wrong), off-by-one errors (start/end boundaries), and wrong update direction (increasing when should decrease). Ensure the update moves the condition toward falsity.

When to use which loop

Use for-loops for fixed counts, while-loops for condition-driven repetition, and do-while when you must execute the body at least once.

Definition: Loop control statements are programming constructs that allow a block of code to be executed repeatedly until a specified condition becomes false. They help automate repetitive tasks and control flow of execution.

Key parts of a loop: initialization (set up loop variable), condition (test to continue), body (statements to repeat), update (change loop variable to eventually stop).

Types of loops (common in CBSE Class 11 contexts / Python):

• for loop — iterates over a sequence (range, list, string). Typical form in Python: for i in range(start, stop, step):
• while loop — repeats as long as a condition is true: while condition:
• do-while loop — present in languages like C/Java (executes body first then checks). Note: Python has no do-while; its behaviour can be simulated with while True + break.

Loop control statements that change normal loop flow:

• break — immediately exits the innermost loop.
• continue — skips the rest of current iteration and continues with next iteration.
• pass (Python) — a placeholder that does nothing (useful when a statement is syntactically required).
• loop-else (Python) — an else block after a loop executes if the loop was not terminated by break.

Example code snippets (Python):

# for loop over range
for i in range(1, 6):
    print(i)  # prints 1 to 5

# while loop
n = 5
sum = 0
i = 1
while i <= n:
    sum += i
    i += 1
print(sum)  # sum of first 5 natural numbers

# break & continue
for x in [2, 4, 7, 9]:
    if x == 7:
        break    # exits loop when 7 is found
    if x % 2 != 0:
        continue # skip odd numbers
    print(x)    # prints only even numbers before break

Important notes:

• Always ensure the loop condition will become false eventually (or use break) to prevent infinite loops.
• Nested loops are loops inside loops. Their total iterations multiply (outer * inner).
• Choose the loop type based on whether you know iteration count beforehand (for) or depend on a condition (while).

Definition: Nested control structures are control statements placed inside other control statements. Common nests include an if (decision) inside another if, a loop inside another loop, or combinations (if inside loop, loop inside if, etc.). The inner structure executes only when the outer structure's flow reaches it.

Why it matters: Nesting lets you express multi-level decisions and multi-dimensional iterations—essential for tasks like validating complex conditions, processing matrices, or implementing multi-step workflows.

Types and short syntax (Python-style):

• Nested if:

  if conditionA:
      if conditionB:
          do_something()

• Nested if-else / if-elif-else:

  if A:
      if B:
          X
      else:
          Y
  else:
      Z

• Nested loops (for inside for):

  for i in range(n):
      for j in range(m):
          process(i, j)

• Loop inside condition / condition inside loop:

  if valid:
      for item in list:
          handle(item)
  
  for x in items:
      if check(x):
          take_action(x)

Execution flow: Control enters the outer construct; when the path reaches the inner construct, execution continues there and returns to the outer construct when the inner completes. In nested loops, the inner loop typically runs completely for each single iteration of the outer loop.

Common pitfalls and tips:

• Deep nesting reduces readability—refactor using functions or switch/elif chains.
• Be careful with break and continue: break exits only the innermost loop where it appears unless used with flags or exceptions.
• Logical combinations can often replace nesting: nested ifs like if A: if B: X can be written if A and B: X for clarity.

Simple examples (Python):

# 1. Nested if: grade classification
marks = 82
if marks >= 40:
    if marks >= 75:
        print('Distinction')
    elif marks >= 60:
        print('First Division')
    else:
        print('Pass')
else:
    print('Fail')

# 2. Nested loops: matrix traversal
matrix = [[1,2,3],[4,5,6],[7,8,9]]
for i in range(3):
    for j in range(3):
        print(matrix[i][j], end=' ')
    print()

# 3. Condition inside loop: find prime numbers up to n
n = 10
for num in range(2, n+1):
    is_prime = True
    for d in range(2, int(num**0.5)+1):
        if num % d == 0:
            is_prime = False
            break
    if is_prime:
        print(num)

Overview
Flowcharts and pseudocode are two complementary ways to describe the flow of control in an algorithm before writing actual code. Both make logic clear: flowcharts use standardized graphical symbols; pseudocode uses structured, language‑like statements in plain text.

Flowcharts — key points

• Definition: A visual diagram that shows the sequence of steps, decisions and data flow using symbols and arrows.
• Common symbols:
  • Oval (Start/End)
  • Parallelogram (Input/Output)
  • Rectangle (Process — assignment, computation)
  • Diamond (Decision — yes/no branching)
  • Arrow (Flow line)
• Uses: plan programs, debug logic, explain algorithms to non-programmers.
• Rules: single entry/exit for blocks, arrows show direction, label decision branches (Yes/No or True/False).

Pseudocode — key points

• Definition: An informal, language‑neutral description of an algorithm using structured statements (IF, FOR, WHILE, etc.). It looks like code but omits syntax details.
• Conventions: use meaningful variable names, indentation to show nesting, keywords like START/END, INPUT/OUTPUT, IF/ELSE, FOR, WHILE, REPEAT...UNTIL.
• Advantages: faster to write than real code, readable by humans, maps directly to programming constructs.

Control structures represented

• Sequence: consecutive steps — both flowchart (series of rectangles) and pseudocode (one statement after another).
• Selection (decision): IF, IF-ELSE — flowchart uses diamond; pseudocode uses IF ... THEN ... ELSE ... ENDIF.
• Iteration (loops): FOR, WHILE, REPEAT-UNTIL — flowchart shows loop with decision back edge; pseudocode uses loop headers and body.

Mapping example (conceptual)

Flowchart: Start -> Input n -> Decision (n % 2 == 0) -> [Yes] Output 'Even' -> End
                                       -> [No]  Output 'Odd'  -> End

Pseudocode:
START
 INPUT n
 IF n % 2 == 0 THEN
   OUTPUT 'Even'
 ELSE
   OUTPUT 'Odd'
 ENDIF
END

Best practice tips

• Keep flowcharts simple: one page per algorithm if possible.
• Use clear labels on decision branches.
• In pseudocode, prefer clarity over syntactic accuracy; consistent indentation is essential.
• When converting between the two, ensure each decision and loop has a matching construct.

What is Input Validation?
Input validation is the process of checking that data entered by a user (or received from another system) is correct, safe and usable before the program processes it. It prevents errors, unexpected behaviour and security problems.

Why it matters: prevents crashes, incorrect results, security vulnerabilities (e.g., injection), and poor user experience. In classroom programs it helps avoid runtime errors and infinite loops.

Types of validation

• Type check — ensure value is integer, float, string, date, etc.
• Range check — ensure numeric values fall inside allowed bounds (e.g., 0–100).
• Format check — ensure string matches pattern (e.g., email, phone) using pattern matching/regular expressions.
• Presence / required check — ensure mandatory fields are not empty.
• Length check — ensure strings have acceptable length.
• Cross-field checks — checks involving multiple fields (e.g., end date ≥ start date).

Common techniques

• Conditional checks (if/else) to test values.
• Try/Except (or try/catch) to handle type conversion errors.
• Loops to re-prompt until valid input is received (input-validation loop).
• Regular expressions for complex format checks.
• Sanitization: remove/escape harmful characters before using input in commands/queries.

Common programming patterns (flow of control)

• Input-validation loop: repeatedly ask for input until it is valid. (while True → validate → break)
• Sentinel-controlled loop: read values repeatedly until a special value (sentinel) indicates end of input.
• Accumulator / running total: keep adding values to a total and possibly count items for average.
• Counter pattern: count occurrences that meet a condition.
• Flag (boolean) pattern: use a flag to indicate whether a condition has occurred (e.g., found = True).
• Menu-driven program: present choices in a loop until the user chooses exit.
• Search pattern: linear search using loops and conditional checks to find an item.
• Find min/max: initialize min/max with first item and iteratively update.

Small Python examples (class 11 level)

# Input-validation loop (age must be integer between 0 and 120)
while True:
    s = input("Enter age: ")
    try:
        age = int(s)
        if 0 <= age <= 120:
            break
        else:
            print("Age must be between 0 and 120")
    except ValueError:
        print("Please enter a valid integer")

# Accumulator & average pattern
count = 0
total = 0
while True:
    s = input("Enter score (or 'done'): ")
    if s.lower() == 'done':
        break
    try:
        x = float(s)
        total += x
        count += 1
    except ValueError:
        print("Invalid score")
if count > 0:
    print("Average:", total/count)
else:
    print("No scores entered")

Best practices

• Use clear, friendly error messages that explain what is expected.
• Limit retries or provide a cancel option to avoid infinite loops.
• Prefer whitelist validation (allowed patterns) over blacklist.
• Centralize validation logic into functions so it can be reused and tested.
• For user interfaces validate both client-side (for convenience) and server-side (for security).

Overview

In the "Flow of Control" chapter, tracing, dry run and debugging logical errors are techniques used to understand how a program executes and to find/fix mistakes that do not produce syntax errors but make the program behave incorrectly (logical errors).

Tracing

Tracing means following the execution of a program step-by-step and recording the values of variables, control-flow decisions, and outputs at each step. A trace table is commonly used: columns for line number/step, variables, and output. Tracing is used to verify how control structures (if/else, loops, nested blocks) change program state.

Dry run

A dry run is a manual execution of an algorithm or program on paper (or mentally) before running it on a computer. It is typically done using representative input values and a trace table. Dry runs help catch logical errors early and ensure the algorithm meets requirements.

Debugging logical errors

Logical errors are mistakes in the algorithm or program logic that cause incorrect outputs while the program still runs (no syntax/runtime error). Debugging logical errors involves:

• Reproducing the incorrect behaviour with test cases.
• Tracing/dry running to isolate the faulty code region.
• Hypothesizing the cause (wrong condition, bad initialization, off-by-one, wrong operator, wrong formula).
• Fixing the code and re-testing with multiple inputs (including edge cases).
• Documenting the fix and, if needed, adding assertions or additional tests.

Common logical error types

• Off-by-one errors in loops (wrong loop bounds).
• Wrong initialization of variables (e.g., sum = 1 instead of 0).
• Incorrect conditionals (using > instead of >=).
• Using the wrong operator (assignment instead of comparison in some languages).
• Incorrect formula implementation (transcription error).
• Incorrect order of operations or misplaced parentheses.

How to perform a trace / dry run (step-by-step)

1. Write the code or pseudocode in numbered steps.
2. Create a trace table with columns: Step/Line, Input(s), Variables (each variable its own column), Output/Notes.
3. Pick test input(s) including normal case, boundary cases and special cases.
4. Execute each step mentally or on paper, updating variables in the table.
5. When you hit an unexpected value, examine the corresponding step to find the logic mistake.

Tips for effective debugging

• Start with a small, simple input that reproduces the bug.
• Add print statements or use a debugger to inspect variable values during execution.
• Check edge cases (0, 1, negative values, empty lists, very large values).
• Simplify the code, isolate components, and test subparts separately.
• Use assertions or unit tests to catch regressions early.

Example trace table (simple)

Program goal: compute sum of first n natural numbers (1..n) using loop. Suppose code mistakenly uses i <= n-1 instead of i <= n.

1. sum = 0
2. i = 1
3. while i <= n-1:
4.   sum = sum + i
5.   i = i + 1
6. print(sum)

Trace table for n = 5

Step | i | sum | Comment
1    | - | 0   | init
2    | 1 | 0   | start loop
3    | 1 | 1   | add 1 (i=1)
4    | 2 | 1   | increment i
3    | 2 | 3   | add 2
4    | 3 | 3   | increment i
3    | 3 | 6   | add 3
4    | 4 | 6   | increment i
3    | 4 |10   | add 4
4    | 5 |10   | increment i
3    | 5 | --  | condition i <= n-1 fails (5 <= 4 false)
End  | - |10   | printed (wrong: expected 15)

This shows the off-by-one error: i never added 5.

Debugging this example

Fixed condition: while i <= n

Real-life analogies / examples

• Recipe analogy (dry run): Before cooking for guests, you mentally rehearse steps and ingredient amounts to ensure the dish will be correct. A logical error would be forgetting to add salt or using sugar instead of salt.
• Driving with GPS (tracing): You follow each turn and note when you deviated. If you took the wrong turn (logical mistake), tracing back step-by-step reveals where you erred.
• Bank ledger balancing (debugging): If the monthly total is off, you check individual transactions (trace) and find a mis-recorded amount (logical error).

When to use tracing / dry run

• When the program compiles/runs but output is incorrect.
• To understand a new algorithm or unfamiliar code before modifying it.
• To prove correctness for small inputs or to find counterexamples.

Tools that help

• Print/console logs to show variable values at checkpoints.
• Interactive debuggers (breakpoints, watch variables, step-over/step-into).
• Unit tests and test harnesses for repeated checks.

Summary

Tracing and dry runs are manual, systematic ways to follow program execution and uncover logical errors. Debugging logical errors requires careful reproduction, isolation, correction and verification. Mastering these techniques increases programmer confidence and produces correct programs.