Programming Fundamentals

Variables, Constants, and Data Types

Variables

A variable is a named storage location in memory whose value can change during program execution. A Variable has a name (identifier), a data type (which determines the kind of data it can hold and how Much memory it occupies), and a value (the data currently stored).

Declaration allocates memory for the variable and associates a name with that location. Initialization assigns an initial value at the point of declaration. Assignment changes the Value stored in the variable after it has been declared.

Constants

A constant is a named storage location whose value cannot change after initialization. Constants Make programs more readable and maintainable by replacing magic numbers with meaningful names. In IB Pseudocode, constants are declared with the CONSTANTS keyword.

CONSTANTS
  MAX_STUDENTS ← 30
  TAX_RATE ← 0.15
  SCHOOL_NAME ← "Springfield High"

Attempting to reassign a constant is a logic error (or a compilation error in statically typed Languages with constant enforcement).

Primitive Data Types

INTEGER vs FLOAT: Integers are exact; floating-point numbers have limited precision due to their Binary representation. This matters for comparison. The expression 0.1 + 0.2 = 0.3 may evaluate to FALSE in many languages because 0.1 + 0.2 is stored as 0.30000000000000004.

CHAR vs STRING: A CHAR is a single character. A STRING is a sequence of zero or more characters. In many languages, a STRING is an array of CHARs with a null terminator or a length field.

BOOLEAN: Named after George Boole. Only two values: TRUE and FALSE. Used as the condition in Selection and iteration constructs, and as the return type of functions that perform checks or Comparisons.

Worked Example: Choosing Data Types

A school management system needs to store the following data. Choose the most appropriate data type For each.

Operators

Arithmetic Operators

DIV vs /: DIV discards the fractional part (truncates toward zero in most IB pseudocode Contexts). / produces a floating-point result. For 7 / 3DIV gives 2 and / gives 2.333…

MOD: Returns the remainder after integer division. 7 MOD 3 = 1 because 7 = 3 * 2 + 1. MOD is Commonly used to test divisibility (e.g., n MOD 2 = 0 tests if n is even), to wrap indices in Circular data structures, and to extract digits.

Worked Example: DIV and MOD to Extract Digits

Extract the hundreds, tens, and units digits of the number n = 472.

n ← 472
hundreds ← n DIV 100       // 472 DIV 100 = 4
remainder ← n MOD 100      // 472 MOD 100 = 72
tens ← remainder DIV 10    // 72 DIV 10 = 7
units ← n MOD 10           // 472 MOD 10 = 2
OUTPUT hundreds, tens, units  // Outputs: 4, 7, 2

Relational (Comparison) Operators

Relational operators always produce a BOOLEAN result. They can be applied to numeric types (comparing magnitude) and string types (comparing lexicographically based on character codes).

Logical Operators

Operator precedence (highest to lowest): NOT, AND, OR. This matters in expressions like:

NOT a AND b OR c

This is evaluated as ((NOT a) AND b) OR cNot NOT (a AND (b OR c)). Use parentheses to make Intent explicit.

Assignment Operator

In IB pseudocode, the assignment operator is the left arrow ←. It evaluates the expression on the Right and stores the result in the variable on the left. Assignment is not equality: count ← count + 1 means “take the current value of countAdd 1, and store the result back in count.”

Bitwise Operators

Bitwise operators operate on the binary representation of integers. Each bit position is treated Independently. Bitwise AND is used for masking (extracting specific bits), bitwise OR is used for Setting bits, and bitwise XOR is used for toggling bits.

Common Pitfalls: Operators

• Operator precedence confusion: Without parentheses, 2 + 3 * 4 evaluates to 14, not 20. Always use parentheses when in doubt: (2 + 3) * 4 = 20.
• Integer division surprise: 7 DIV 2 gives 3, not 3.5. If a fractional result is needed, use / instead of DIV.
• MOD with negative numbers: The behavior of MOD with negative operands varies between languages. In IB pseudocode, focus on non-negative operands to avoid ambiguity.
• Confusing = (comparison) with ← (assignment): In IB pseudocode these are distinct, but in many programming languages = is assignment and == is comparison. Mixing them up causes logic errors that are hard to spot.
• Bitwise vs logical operators: AND and OR in IB pseudocode are logical operators that work on BOOLEAN values. Bitwise AND/OR work on the binary representation of integers. Do not confuse them.

Control Structures

Sequence

Sequence is the default control structure: statements execute one after another in the order they Appear. Every program is ultimately a sequence of operations, possibly interspersed with selections And iterations.

Selection

Selection allows the program to choose between different paths of execution based on a condition.

IF…THEN…ELSE:

IF grade >= 50
  THEN
    OUTPUT "Pass"
    passed ← passed + 1
  ELSE
    OUTPUT "Fail"
    failed ← failed + 1
END IF

Nested IF:

IF score >= 90
  THEN OUTPUT "Grade: A"
  ELSE IF score >= 80
    THEN OUTPUT "Grade: B"
    ELSE IF score >= 70
      THEN OUTPUT "Grade: C"
      ELSE IF score >= 60
        THEN OUTPUT "Grade: D"
        ELSE OUTPUT "Grade: F"
      END IF
    END IF
  END IF
END IF

CASE (switch): The CASE structure is cleaner when there are multiple discrete values to compare Against:

CASE OF month
  1 : OUTPUT "January"
  2 : OUTPUT "February"
  3 : OUTPUT "March"
  ...
  12: OUTPUT "December"
  OTHERWISE OUTPUT "Invalid month"
ENDCASE

CASE is appropriate when the selection is based on a single variable being tested against specific Values. Nested IF is appropriate when conditions involve different variables or ranges.

Worked Example: Tracing a Selection Structure

Trace the following pseudocode with score = 75:

IF score >= 90
  THEN grade ← "A"
  ELSE IF score >= 80
    THEN grade ← "B"
    ELSE IF score >= 70
      THEN grade ← "C"
      ELSE IF score >= 60
        THEN grade ← "D"
        ELSE grade ← "F"
      END IF
    END IF
  END IF
END IF
OUTPUT grade

Iteration

FOR loop (counted loop): Executes a fixed number of times.

FOR i ← 1 TO 10
  OUTPUT i
END FOR

The loop variable i is automatically initialized to 1, incremented by 1 after each iteration, and The loop terminates when i exceeds 10. IB pseudocode also supports stepping:

FOR i ← 10 DOWNTO 1
  OUTPUT i
END FOR

WHILE loop (pre-test conditional loop): Tests the condition before each iteration. The loop body May execute zero times.

WHILE count < target
  count ← count + 1
END WHILE

Use WHILE when the number of iterations is not known in advance and the loop may not execute at all.

REPEAT…UNTIL loop (post-test conditional loop): Tests the condition after each iteration. The Loop body always executes at least once.

REPEAT
  INPUT password
UNTIL password = correctPassword

Use REPEAT…UNTIL when the loop body must execute at least once (e.g., prompting for input that Must be validated).

Comparison of Loop Constructs

Nested Loops

A loop inside another loop. The inner loop completes all its iterations for each single iteration of The outer loop.

Worked example: Print a multiplication table for 1 to 5.

FOR i ← 1 TO 5
  FOR j ← 1 TO 5
    OUTPUT i * j, " "
  END FOR
  OUTPUT newLine
END FOR

The inner loop executes 5 times for each of the 5 iterations of the outer loop, giving a total of 25 Iterations. For nested loops with outer loop size $m$ and inner loop size $n$The total iterations Are $m \times n$.

Common Loop Patterns

Accumulator pattern: Maintain a running total.

total ← 0
FOR i ← 1 TO n
  total ← total + arr[i]
END FOR

Counter pattern: Count occurrences of a condition.

count ← 0
FOR i ← 0 TO LENGTH(arr) - 1
  IF arr[i] > threshold
    THEN count ← count + 1
  END IF
END FOR

Sentinel pattern: Loop until a special value is encountered.

REPEAT
  INPUT value
  IF value <> -1
    THEN total ← total + value
  END IF
UNTIL value = -1
**Flag pattern:** Use a boolean to signal loop termination.

Found ← FALSE I ← 0 WHILE i < LENGTH(arr) AND found = FALSE IF arr[i] = target THEN found ← TRUE END IF i ← i + 1 END WHILE

Common Pitfalls: Loops

• Off-by-one errors: The most common loop bug. For an array of size $n$Valid indices are $0$ to $n - 1$. A FOR loop from $0$ TO $n$ would access index $n$Which is out of bounds. Always trace with boundary values.
• Infinite WHILE loops: If the loop variable is never updated inside the loop body, the condition never changes and the loop runs forever. Always ensure the loop variable moves toward the termination condition.
• Modifying the FOR loop variable: Changing the loop variable inside a FOR loop body (e.g., i ← i + 2 inside FOR i ← 1 TO 10) produces unpredictable results depending on the language. Use a WHILE loop if you need non-standard stepping.
• REPEAT…UNTIL runs at least once: Do not use REPEAT…UNTIL when the loop body might not need to execute at all. If a file could be empty, a REPEAT…UNTIL that reads from it would still execute once with no data.

Procedures and Functions

Procedures

A procedure is a named block of code that performs a specific task. It does not return a value. It Is called for its side effects (e.g., printing output, modifying global state, updating data Structures).

PROCEDURE printStars(n)
  FOR i ← 1 TO n
    OUTPUT "*"
  END FOR
END PROCEDURE

Functions

A function is a named block of code that performs a computation and returns a value. Functions Should not have side effects — they should be pure: the same inputs always produce the same output.

FUNCTION factorial(n) RETURNS INTEGER
  IF n <= 1
    THEN RETURN 1
  END IF
  RETURN n * factorial(n - 1)
END FUNCTION

Parameters and Return Values

Parameters are variables listed in the procedure or function definition that receive values from The caller. Arguments are the actual values passed when the procedure or function is called.

FUNCTION rectangleArea(length, width) RETURNS REAL
  RETURN length * width
END FUNCTION

area ← rectangleArea(5.0, 3.0)  // 5.0 and 3.0 are arguments

Return values: A function uses the RETURN statement to send a result back to the caller. Execution of the function terminates immediately when RETURN is encountered. A procedure does not Have a return value.

Side Effects

A side effect occurs when a function or procedure modifies state outside its local scope. Side Effects include modifying global variables, performing I/O, and mutating arguments passed by Reference. Pure functions have no side effects: they depend only on their inputs and produce only a Return value.

Side effects make code harder to reason about, test, and debug because the behavior of a function Depends on the state of the entire program, not just its inputs.

Worked Example: Designing a Function

Write an IB pseudocode function celsiusToFahrenheit(c) that converts a temperature from Celsius to Fahrenheit. Use it to convert 100 degrees and display the result.

FUNCTION celsiusToFahrenheit(c) RETURNS REAL
  RETURN c * 9 / 5 + 32
END FUNCTION

result ← celsiusToFahrenheit(100)
OUTPUT result  // Outputs: 212.0

Common Pitfalls: Procedures and Functions

• Calling a procedure like a function: A procedure does not return a value. Writing result ← printStars(5) is an error because printStars is a procedure, not a function.
• Missing RETURN statement: If a function has a code path that does not execute a RETURN statement, the behavior is undefined. Always ensure every path through a function ends with a RETURN.
• Side effects in functions: A function that modifies a global variable or prints output is not pure. This makes the function harder to test and reason about. Keep functions pure; use procedures for side effects.
• Parameter count mismatch: Calling a function with too many or too few arguments causes an error. Always check the function definition to verify the expected number and types of parameters.

Parameter Passing

By Value (Pass by Value)

A copy of the argument’s value is passed to the parameter. Modifications to the parameter inside the Function do not affect the original argument.

PROCEDURE increment(x)
  x ← x + 1
  OUTPUT x
END PROCEDURE

num ← 10
increment(num)
OUTPUT num  // Outputs 10 (unchanged)

The parameter x is a local copy. Changing it has no effect on num.

By Reference (Pass by Reference)

The memory address of the argument is passed to the parameter. Modifications to the parameter inside The function directly affect the original argument.

PROCEDURE increment(REF x)
  x ← x + 1
  OUTPUT x
END PROCEDURE

num ← 10
increment(num)
OUTPUT num  // Outputs 11 (changed)

The REF keyword in IB pseudocode indicates pass by reference. The parameter x is an alias for numSo changing x changes num.

Comparison

Worked Example: Tracing By-Value vs By-Reference

Trace the following pseudocode and predict all outputs:

PROCEDURE swapByValue(a, b)
  temp ← a
  a ← b
  b ← temp
  OUTPUT a, b
END PROCEDURE

PROCEDURE swapByRef(REF a, REF b)
  temp ← a
  a ← b
  b ← temp
  OUTPUT a, b
END PROCEDURE

x ← 10
y ← 20
swapByValue(x, y)
OUTPUT x, y

swapByRef(x, y)
OUTPUT x, y

Recursion

Recursion is a problem-solving technique where a function calls itself to solve smaller instances of The same problem. Every recursive solution has two essential components:

Base case: The condition under which the function returns directly without making a recursive Call. Without a base case, the recursion never terminates (infinite recursion), eventually causing a Stack overflow.

Recursive case: The condition under which the function calls itself with a modified argument That moves closer to the base case.

Worked Example: Factorial

FUNCTION factorial(n) RETURNS INTEGER
  IF n <= 1
    THEN RETURN 1         // Base case
  END IF
  RETURN n * factorial(n - 1)  // Recursive case
END FUNCTION

Call stack trace for factorial(4):

Worked Example: Fibonacci

FUNCTION fibonacci(n) RETURNS INTEGER
  IF n <= 1
    THEN RETURN n
  END IF
  RETURN fibonacci(n - 1) + fibonacci(n - 2)
END FUNCTION

This naive recursive Fibonacci has exponential time complexity $O(2^n)$ because each call spawns two Sub-calls. The call tree for fibonacci(5) has 15 calls total. For fibonacci(40)There are over 300 million calls. This demonstrates why recursion must be used carefully — memoization or an Iterative approach is required for practical Fibonacci computation.

Worked Example: Sum of Array

FUNCTION arraySum(arr, index) RETURNS INTEGER
  IF index >= LENGTH(arr)
    THEN RETURN 0
  END IF
  RETURN arr[index] + arraySum(arr, index + 1)
END FUNCTION

This is tail-recursive (the recursive call is the last operation). Some compilers optimize tail Recursion into iteration to avoid stack growth.

When to Use Recursion vs Iteration

Worked Example: Tracing a Recursive Function

Trace mystery(4) where:

FUNCTION mystery(n) RETURNS INTEGER
  IF n = 1
    THEN RETURN 1
  END IF
  RETURN n + mystery(n - 1)
END FUNCTION

Common Pitfalls: Recursion

• No base case or unreachable base case: Without a valid base case, recursion is infinite. For factorial(n) with n = -1The base case n \lt{}= 1 is never reached because the recursive call uses n - 1Making the argument more negative each time.
• Stack overflow: Each recursive call adds a frame to the call stack. For deep recursion (e.g., naive fibonacci(1000)), the stack exceeds available memory. Prefer iteration for problems requiring many levels.
• Redundant computation: Naive recursive Fibonacci makes $O(2^n)$ calls because it recomputes the same values repeatedly. Use memoization (caching results) or convert to iteration for efficiency.

Programming Paradigms

Procedural Programming

Programs are structured as a sequence of instructions that operate on data. Data and functions are Separate. The focus is on “what to do” step by step. Variables are shared globally or passed between Procedures.

Characteristics: Top-down design, stepwise refinement, procedures and functions, global and Local scope, sequential execution.

Languages: C, Pascal, Fortran, BASIC.

Strengths: Simple to understand for small programs, efficient execution, close to hardware.

Weaknesses: Difficult to maintain for large programs, data is not protected (global variables Can be modified anywhere), limited code reuse.

Object-Oriented Programming (OOP)

Programs are organized around objects that combine data (attributes) and behavior (methods). Objects Are instances of classes, which define the structure and behavior.

Characteristics: Encapsulation, inheritance, polymorphism, abstraction, classes and objects, Message passing.

Languages: Java, Python, C++, C#.

Strengths: Data hiding and protection, code reuse through inheritance, natural modeling of Real-world entities, easier maintenance of large systems.

Weaknesses: Steeper learning curve, runtime overhead from objects and method dispatch, can be Overkill for simple programs.

Functional Programming

Programs are structured as a composition of pure functions. Data is immutable — once created, it Cannot be changed. Functions are first-class citizens (they can be passed as arguments, returned as Values, and stored in data structures).

Characteristics: Pure functions, immutability, higher-order functions, recursion instead of Loops, function composition.

Languages: Haskell, Lisp, Erlang, F#.

Strengths: No side effects (easier to reason about, test, and debug), natural support for Parallelism (no shared mutable state), mathematical elegance.

Weaknesses: Can be less intuitive for stateful problems, immutability can lead to performance Overhead (creating new copies of data structures), steep learning curve for imperative programmers.

Paradigm Comparison

Worked Example: Identifying Programming Paradigms

Identify the programming paradigm demonstrated by each code snippet.

total ← 0
FOR i ← 0 TO LENGTH(scores) - 1
  total ← total + scores[i]
END FOR
average ← total / LENGTH(scores)
OUTPUT average

CLASS Student
  PRIVATE name : STRING
  PRIVATE grade : INTEGER

  PUBLIC PROCEDURE setName(n)
    name ← n
  END PROCEDURE

  PUBLIC FUNCTION getGrade() RETURNS INTEGER
    RETURN grade
  END FUNCTION
END CLASS

s ← NEW Student()
s.setName("Alice")
OUTPUT s.getGrade()

FUNCTION applyDiscount(price, discount) RETURNS REAL
  RETURN price - price * discount
END FUNCTION

FUNCTION addTax(amount, rate) RETURNS REAL
  RETURN amount + amount * rate
END FUNCTION

finalPrice ← addTax(applyDiscount(100.0, 0.1), 0.05)

Pseudocode and Flowchart Conventions

IB Pseudocode Standard

The IB defines a specific pseudocode standard. Key elements:

Variable assignment: variable ← expression

Input/output: INPUT variable``OUTPUT expression

Selection: IF ... THEN ... ELSE IF ... ELSE ... END IF

Case selection: CASE OF ... ENDCASE

Counted loop: FOR variable ← start TO end ... END FOR

Pre-test loop: WHILE condition ... END WHILE

Post-test loop: REPEAT ... UNTIL condition

Procedures: PROCEDURE name(params) ... END PROCEDURE

Functions: FUNCTION name(params) RETURNS type ... END FUNCTION

Arrays: Zero-indexed, arr[i]``matrix[i, j]

Comments: Use // for single-line comments.

Nassi-Shneiderman Diagrams

Nassi-Shneiderman diagrams (also called structorgrams) are a structured alternative to traditional Flowcharts. They eliminate the need for flow lines (arrows) by using nested rectangular blocks. This Enforces structured programming — there is no way to represent a GOTO or unstructured branching.

The diagram uses three fundamental structures:

1. Process block: A simple rectangle containing a sequence of statements.
2. Selection block: A rectangle divided into sections. For IF/ELSE, the block is split vertically into two parts (true and false branches). For CASE, the block is divided into multiple columns.
3. Iteration block: A rectangle with a condition at the top and the loop body below. For WHILE loops, the condition is tested first. For REPEAT…UNTIL loops, the body appears first and the condition appears at the bottom.

Nassi-Shneiderman diagrams are particularly useful for illustrating structured algorithms because They make the nesting of control structures visually explicit. They cannot represent unstructured Jumps, which is both a strength (enforcing good practice) and a limitation (cannot represent certain Low-level algorithms).

Worked Example: Converting a Problem Description to IB Pseudocode

Problem: Read 10 exam scores from the user, calculate the average, and output “Above average” if The average is greater than 60, otherwise output “At or below average.”

CONSTANTS
  NUM_SCORES ← 10
  PASS_THRESHOLD ← 60

total ← 0
FOR i ← 1 TO NUM_SCORES
  INPUT score
  total ← total + score
END FOR

average ← total / NUM_SCORES
IF average > PASS_THRESHOLD
  THEN OUTPUT "Above average: ", average
  ELSE OUTPUT "At or below average: ", average
END IF

Debugging and Testing

Error Types

Syntax errors: Violations of the language’s grammar rules. Detected at compile time (or parse Time for interpreted languages). The program will not run until all syntax errors are fixed.

Examples: missing semicolons, mismatched parentheses, misspelled keywords, undeclared variables.

Logic errors: The program runs without crashing but produces incorrect results. The code does Something different from what the programmer intended. Logic errors are the most difficult to find Because the program appears to work.

Examples: off-by-one errors in loop bounds, incorrect comparison operators, wrong formula, using Assignment (=) instead of comparison (==) in a condition.

Runtime errors: Errors that occur during program execution. The program compiles successfully But crashes or produces unexpected behavior when run.

Examples: division by zero, array index out of bounds, stack overflow from infinite recursion, null Pointer dereference, insufficient memory.

Debugging Strategies

Trace tables: Systematically record the value of each variable at each step of execution. This Is the primary debugging technique in IB examinations.

FUNCTION mystery(n) RETURNS INTEGER
  result ← 0
  i ← 1
  WHILE i <= n
    result ← result + i * i
    i ← i + 1
  END WHILE
  RETURN result
END FUNCTION

Trace with n = 3:

The function returns 14, which is $1^2 + 2^2 + 3^2 = 14$. It computes the sum of squares.

Worked Example: Selecting Test Data

A function getLetterGrade(score) accepts an integer score from 0 to 100 and returns a letter grade (A: 90-100, B: 80-89, C: 70-79, D: 60-69, F: 0-59). Identify appropriate test data for each Category.

Print statements (dry running): Insert output statements at key points to observe variable Values during execution.

Breakpoints: Pause execution at a specific line and inspect the program state. Available in IDEs.

Rubber duck debugging: Explain the code line by line to an inanimate object (or a colleague). The act of verbalizing often reveals the error.

Testing Strategies

Unit testing: Testing individual functions or procedures in isolation. Each unit test provides a Specific input and checks whether the output matches the expected result. A comprehensive test suite Covers normal cases, boundary cases, and error cases.

Integration testing: Testing the interactions between multiple units (functions, modules, Components) to ensure they work together correctly.

System testing: Testing the entire system as a whole to verify that it meets all requirements.

Black-box testing: Testing without knowledge of the internal code. Tests are based on the Specification: given these inputs, the expected output is X.

White-box testing: Testing with knowledge of the internal code. Tests are designed to exercise Specific paths, branches, and conditions in the code.

Test Data Categories

Worked Example: Constructing an Advanced Trace Table

Trace the following function with arr = [5, 3, 8, 1, 8, 3] and target = 8:

FUNCTION countAndFind(arr, target) RETURNS INTEGER
  count ← 0
  firstIndex ← -1
  i ← 0
  WHILE i < LENGTH(arr)
    IF arr[i] = target
      THEN
        count ← count + 1
        IF firstIndex = -1
          THEN firstIndex ← i
        END IF
    END IF
    i ← i + 1
  END WHILE
  OUTPUT "First at: ", firstIndex, " Count: ", count
  RETURN count
END FUNCTION

Common Pitfalls: Debugging and Testing

• Incomplete trace tables: Every variable that changes must have a column. Forgetting to include a variable (like the loop counter i) means the trace is incomplete and may miss errors.
• Testing only normal cases: A test suite that only tests valid inputs within the expected range will miss boundary and error cases. Always include boundary values (0, 1, maximum) and invalid inputs.
• Confusing syntax errors with logic errors: A program that compiles successfully can still produce wrong results. Fixing compilation errors does not guarantee correctness. Always verify output against expected results.
• Not testing edge cases: For a function that processes an array, test with an empty array, a single-element array, and an array where all elements are the same. These edge cases often reveal bugs.

Exception Handling

Exception handling is a mechanism for managing runtime errors gracefully without crashing the Program. When an exceptional condition occurs (e.g., division by zero, file not found, invalid Input), an exception object is created and “thrown.” The program can “catch” the exception and take Corrective action.

Try-Catch-Finally Pattern

TRY
  result ← numerator / denominator
  OUTPUT result
CATCH error
  OUTPUT "Error: Division by zero"
FINALLY
  OUTPUT "Calculation attempted"
END TRY

The TRY block contains the code that might throw an exception. The CATCH block handles the Exception if one occurs. The FINALLY block executes regardless of whether an exception occurred — It is used for cleanup operations like closing files or releasing resources.

Worked Example: Exception Handling in Practice

Write IB pseudocode that prompts the user for two integers and outputs their quotient. Handle the case Where the second number is zero.

LOOP
  TRY
    INPUT numerator
    INPUT denominator
    IF denominator = 0
      THEN RAISE "DivisionError"
    END IF
    result ← numerator / denominator
    OUTPUT numerator, " / ", denominator, " = ", result
    EXIT  // Success: leave the loop
  CATCH error
    IF error = "DivisionError"
      THEN OUTPUT "Error: Cannot divide by zero. Try again."
      ELSE OUTPUT "Unexpected error: ", error
    END IF
  END TRY
END LOOP

Common Pitfalls by Construct

Selection:

• Using = (assignment) instead of == (comparison) in conditions. In IB pseudocode this is less of an issue since = is the comparison operator, but in languages like C/Java this is a frequent bug.
• Forgetting the ELSE branch when all cases should be handled, leading to silent failures.
• Overlapping conditions in nested IF statements, where a later condition can never be reached because an earlier one already covers it.

Iteration:

• Off-by-one errors: using $\le$ instead of < (or vice versa) in loop conditions. Always verify with boundary values.
• Infinite loops: forgetting to update the loop variable in a WHILE loop, or setting a condition that can never become false.
• Modifying the loop variable inside the loop body (in a FOR loop), which can produce unexpected behavior depending on the language.
• Fence-post errors: looping one time too many or one time too few. For an array of size $n$Valid indices are $0$ to $n - 1$.

Recursion:

• Missing base case, causing infinite recursion and stack overflow.
• Base case that is never reached, e.g., factorial(-1) calls factorial(-2)Which calls factorial(-3)And so on indefinitely.
• Excessive recursion depth for problems that could be solved iteratively, leading to performance degradation.
• Redundant recursive calls that recompute the same values, leading to exponential time complexity (as in the naive Fibonacci implementation).

Parameters:

• Passing by value when by reference is needed (the original variable will not be modified).
• Passing by reference when by value is intended (the original variable will be unexpectedly modified).
• Modifying a by-value parameter and expecting the change to persist after the function returns.

Data types:

• Integer overflow: exceeding the maximum representable value. For a 32-bit signed integer, the range is $-2,147,483,648$ to $2,147,483,647$. Adding 1 to the maximum produces $-2,147,483,648$ (wrap around).
• Floating-point precision: comparing floating-point numbers for exact equality is unreliable due to rounding errors. Use a tolerance: ABS(a - b) < epsilon where epsilon is a small value like $10^{-9}$.
• Type coercion: implicitly converting between types (e.g., integer to float) can cause unexpected results. In some languages, 7 / 2 gives 3 (integer division), while 7.0 / 2 gives 3.5.

Problem Set: 15 IB-Style Questions

Q1. State the most appropriate primitive data type for each of the following: (a) The number of students in a school (b) A student’s phone number (e.g., “555-1234”) (c) Whether a user is an administrator (d) A single menu option character (A, B, C, or Q) (e) The current temperature to one decimal place

Q2. Evaluate the following IB pseudocode expression step by step, showing the result after each Operator:

result ← (17 DIV 4) + (17 MOD 4) * 2 ^ 3 - 1

Q3. Given a ← TRUE``b ← FALSE``c ← TRUEEvaluate each expression: (a) NOT a AND b (b) a OR b AND c (c) NOT (a OR b) XOR c (d) (a AND b) OR (NOT b AND c)

Q4. Explain the difference between "apple" < "banana" and "Zebra" < "apple" in terms of string Comparison. What will each expression evaluate to?

Q5. Trace the following pseudocode with score ← 55 and state the output:

IF score >= 90
  THEN grade ← "A"
  ELSE IF score >= 80
    THEN grade ← "B"
    ELSE IF score >= 70
      THEN grade ← "C"
      ELSE IF score >= 60
        THEN grade ← "D"
        ELSE grade ← "F"
      END IF
    END IF
  END IF
END IF
OUTPUT grade

Q6. Rewrite the following nested IF statement as a CASE statement:

IF day = 1
  THEN OUTPUT "Monday"
  ELSE IF day = 2
    THEN OUTPUT "Tuesday"
    ELSE IF day = 3
      THEN OUTPUT "Wednesday"
      ELSE IF day = 4
        THEN OUTPUT "Thursday"
        ELSE IF day = 5
          THEN OUTPUT "Friday"
          ELSE IF day = 6 OR day = 7
            THEN OUTPUT "Weekend"
            ELSE OUTPUT "Invalid"
          END IF
        END IF
      END IF
    END IF
  END IF
END IF

CASE OF day
  1 : OUTPUT "Monday"
  2 : OUTPUT "Tuesday"
  3 : OUTPUT "Wednesday"
  4 : OUTPUT "Thursday"
  5 : OUTPUT "Friday"
  6 : OUTPUT "Weekend"
  7 : OUTPUT "Weekend"
  OTHERWISE OUTPUT "Invalid"
ENDCASE

Q7. What is the output of the following pseudocode?

FOR i ← 1 TO 4
  output ← ""
  FOR j ← 1 TO i
    output ← output + "*"
  END FOR
  OUTPUT output
END FOR

*
**
***
****

Q8. Write IB pseudocode that reads positive integers from the user until the user enters 0. The Program should then output the sum, count, and average of all numbers entered (excluding the 0).

sum ← 0
count ← 0
REPEAT
  INPUT value
  IF value > 0
    THEN
      sum ← sum + value
      count ← count + 1
    END IF
UNTIL value = 0

IF count > 0
  THEN
    average ← sum / count
    OUTPUT "Sum: ", sum
    OUTPUT "Count: ", count
    OUTPUT "Average: ", average
  ELSE
    OUTPUT "No positive numbers were entered."
END IF

Q9. Explain the key difference between a WHILE loop and a REPEAT…UNTIL loop. For each scenario, State which loop is more appropriate and explain why: (a) Validating user input (must prompt at least once) (b) Processing items in a queue that may be empty (c) Searching for a value in a sorted array using binary search

Q10. How many times does the statement OUTPUT i, j execute in total?

FOR i ← 0 TO 4
  FOR j ← i TO 4
    OUTPUT i, j
  END FOR
END FOR

Q11. Write an IB pseudocode function isPrime(n) that returns TRUE if n is a prime number and FALSE otherwise.

FUNCTION isPrime(n) RETURNS BOOLEAN
  IF n < 2
    THEN RETURN FALSE
  END IF
  IF n = 2
    THEN RETURN TRUE
  END IF
  IF n MOD 2 = 0
    THEN RETURN FALSE
  END IF
  i ← 3
  WHILE i * i <= n
    IF n MOD i = 0
      THEN RETURN FALSE
    END IF
    i ← i + 2
  END WHILE
  RETURN TRUE
END FUNCTION

Q12. Trace the following pseudocode and state the final values of a``bAnd c:

PROCEDURE modify(REF x, y, REF z)
  x ← x + y
  y ← y * 2
  z ← x + z
END PROCEDURE

a ← 5
b ← 3
c ← 10
modify(a, b, c)
OUTPUT a, b, c

Q13. Construct a trace table showing the evaluation of factorial(5). How many stack frames are Created, and what is the final return value?

FUNCTION factorial(n) RETURNS INTEGER
  IF n <= 1
    THEN RETURN 1
  END IF
  RETURN n * factorial(n - 1)
END FUNCTION

Q14. The following function is intended to return the sum of all elements in an array. It contains A logic error. Identify the error, explain why it is wrong, and provide the corrected version.

FUNCTION arrayTotal(arr) RETURNS INTEGER
  total ← 0
  FOR i ← 1 TO LENGTH(arr)
    total ← total + arr[i]
  END FOR
  RETURN total
END FUNCTION

FUNCTION arrayTotal(arr) RETURNS INTEGER
  total ← 0
  FOR i ← 0 TO LENGTH(arr) - 1
    total ← total + arr[i]
  END FOR
  RETURN total
END FUNCTION

Q15. Write IB pseudocode for a program that repeatedly asks the user to enter a student’s score (0—100). The program should:

• Reject scores outside the range 0—100 and ask again.
• Stop when the user enters -1.
• After stopping, output the number of valid scores entered and the average score.

CONSTANTS
  MIN_SCORE ← 0
  MAX_SCORE ← 100
  SENTINEL ← -1

total ← 0
count ← 0
LOOP
  INPUT score
  IF score = SENTINEL
    THEN EXIT
  END IF
  IF score >= MIN_SCORE AND score <= MAX_SCORE
    THEN
      total ← total + score
      count ← count + 1
    ELSE
      OUTPUT "Invalid score. Enter a value between 0 and 100."
    END IF
END LOOP

IF count > 0
  THEN
    average ← total / count
    OUTPUT "Valid scores entered: ", count
    OUTPUT "Average score: ", average
  ELSE
    OUTPUT "No valid scores were entered."
END IF

Common Pitfalls

1. Forgetting edge cases in algorithm design (e.g., empty input, single element, already sorted data).

2. Forgetting that $O(n \log n)$ average-case for quicksort becomes $O(n^2)$ worst-case on already sorted input.

3. Misunderstanding the difference between a stack (LIFO) and a queue (FIFO) in data structure applications.

4. Mixing up Big O, Big $\Omega$, and Big $\Theta$ notation — Big O is an upper bound, not necessarily tight.

Cross-References

Summary

The key principles covered in this topic are linked in the sub-pages above. Focus on understanding the definitions, applying the formulas or frameworks, and evaluating strengths and limitations of each approach.

Worked Examples

Worked examples demonstrating the application of key concepts are covered in the detailed sub-pages linked above.