Pseudocode Hub

Arithmetic operators perform mathematical calculations on numeric values (INTEGER and REAL). CIE pseudocode supports six arithmetic operators — four are familiar from maths class, while MOD and DIV are specialised for integer work.

DECLARE Total : INTEGER
DECLARE Count : INTEGER
DECLARE Average : REAL

Total <- 17
Count <- 5

Average <- Total / Count          // 3.4 (REAL division)
OUTPUT Total DIV Count            // 3    (integer quotient)
OUTPUT Total MOD Count            // 2    (remainder)
OUTPUT Average                    // 3.4

Notice how DIV truncates (drops the decimal) rather than rounding — 17 DIV 5 is 3, not 4, even though 17 ÷ 5 = 3.4 rounds to 3.

Relational operators compare two values and always produce aBOOLEAN result — either TRUE or FALSE. They are the building blocks of every IF condition and every loop condition.

DECLARE Age : INTEGER
INPUT Age

IF Age >= 18 THEN
    OUTPUT "You can vote."
ENDIF

IF Age <> 0 THEN
    OUTPUT "Age is not zero."
ENDIF

IF Age = 18 THEN
    OUTPUT "Exactly eighteen!"
ENDIF

Each condition (Age >= 18, Age <> 0, Age = 18) evaluates to TRUE or FALSE, and the IF statement acts on that BOOLEAN result.

Logical operators combine or modify BOOLEAN values. They let you build complex conditions from simpler ones — for example, "age is at least 13 AND age is at most 19" describes a teenager. CIE pseudocode supports three logical operators.

The truth tables below show every possible combination of inputs and the resulting output:

DECLARE Age : INTEGER
DECLARE HasTicket : BOOLEAN

INPUT Age
INPUT HasTicket

IF Age >= 18 AND HasTicket = TRUE THEN
    OUTPUT "Welcome to the show."
ENDIF

IF Age < 13 OR Age > 65 THEN
    OUTPUT "Discount applies."
ENDIF

IF NOT HasTicket THEN
    OUTPUT "Please buy a ticket first."
ENDIF

When an expression contains several operators, CIE pseudocode evaluates them in a fixed order called operator precedence. Operators with higher precedence are evaluated first. Understanding this order is essential — getting it wrong is one of the most common sources of logic errors in exams.

// Example 1: Arithmetic precedence
OUTPUT 2 + 3 * 4        // 14, NOT 20  (* first, then +)

// Example 2: Parentheses override precedence
OUTPUT (2 + 3) * 4      // 20  (parentheses force + first)

// Example 3: Relational + Logical
// Age >= 13 is evaluated first (relational),
// then AND, then OR (lowest)
IF Age >= 13 AND Age <= 19 OR Age = 65 THEN
    OUTPUT "Teenager or senior"
ENDIF

// Example 4: NOT has higher precedence than AND
IF NOT A AND B THEN
    // means: (NOT A) AND B  -- NOT applied to A first
ENDIF

When in doubt, use parentheses to make your intended order explicit. Even if the default precedence would give the same result, parentheses make the code easier to read and remove ambiguity for both you and the examiner.

Real-world conditions rarely use a single operator. You will often combine arithmetic, relational, and logical operators in one expression — for example, to check whether a value falls in a range, or to test multiple criteria at once. The key is to read the expression using the precedence rules and to use parentheses liberally for clarity.

DECLARE Score : INTEGER
DECLARE Attendance : INTEGER

INPUT Score
INPUT Attendance

// Combining arithmetic, relational, and logical operators
IF Score >= 80 AND Attendance >= 90 THEN
    OUTPUT "Grade A with excellent attendance"
ELSE
    IF Score >= 50 AND (Attendance >= 50 OR Score >= 90) THEN
        OUTPUT "Pass"
    ELSE
        OUTPUT "Fail"
    ENDIF
ENDIF

// Using MOD to check for multiples
IF Score MOD 10 = 0 THEN
    OUTPUT "Score is a multiple of 10"
ENDIF

Here is a quick recap of everything we've covered on operators:

• Six arithmetic operators — +, -, *, /, DIV, MOD. Use / for REAL division, DIV for integer quotient, MOD for remainder.
• Relational operators return BOOLEAN — =, <>, <, >, <=, >= always produce TRUE or FALSE. They are the basis of every condition.
• = is comparison, <- is assignment — In CIE pseudocode the single = asks "are these equal?" while <- stores a value. Do not confuse them.
• Three logical operators — AND (both true), OR (at least one true), NOT (inverts a single boolean). Memorise their truth tables.
• Precedence order: PARL — Parentheses, Arithmetic, Relational, Logical. Within arithmetic: * / MOD DIV before + -. Within logical: NOT, AND, OR.
• Use parentheses for clarity — When combining operators, parentheses make your intended order explicit and avoid precedence bugs.