Cambridge pseudocode examples

OUTPUT "Hello, World!"

// Declare variables
DECLARE Name : STRING
DECLARE Age : INTEGER
DECLARE Height : REAL

// Declare constants
CONSTANT PI <- 3.14159
CONSTANT TAX_RATE <- 0.15

OUTPUT "Enter your name:"
INPUT Name
OUTPUT "Enter your age:"
INPUT Age

OUTPUT "Hello, ", Name, "!"
OUTPUT "You are ", Age, " years old"
OUTPUT "Pi value: ", PI

DECLARE Name : STRING
OUTPUT "Enter your name:"
INPUT Name
OUTPUT "Hello, ", Name

DECLARE FirstName : STRING
DECLARE LastName : STRING
DECLARE Age : INTEGER

OUTPUT "Enter first name:"
INPUT FirstName
OUTPUT "Enter last name:"
INPUT LastName
OUTPUT "Enter age:"
INPUT Age

OUTPUT "Full name: ", FirstName, " ", LastName
OUTPUT "Age: ", Age

DECLARE A : INTEGER
DECLARE B : INTEGER

OUTPUT "Enter first number:"
INPUT A
OUTPUT "Enter second number:"
INPUT B

OUTPUT "Addition: ", A + B
OUTPUT "Subtraction: ", A - B
OUTPUT "Multiplication: ", A * B
OUTPUT "Division: ", A / B
OUTPUT "Power: ", A ^ B
OUTPUT "DIV (quotient): ", DIV(A, B)
OUTPUT "MOD (remainder): ", MOD(A, B)

DECLARE Age : INTEGER
DECLARE HasLicense : BOOLEAN

OUTPUT "Enter your age:"
INPUT Age
OUTPUT "Do you have a license? (TRUE/FALSE):"
INPUT HasLicense

IF Age >= 18 AND HasLicense = TRUE THEN
    OUTPUT "You can drive"
ELSEIF Age >= 18 AND HasLicense = FALSE THEN
    OUTPUT "You need to get a license"
ELSE
    OUTPUT "You are too young"
ENDIF

DECLARE Score : INTEGER

OUTPUT "Enter your score:"
INPUT Score

IF Score >= 50 THEN
    OUTPUT "Pass"
ELSE
    OUTPUT "Fail"
ENDIF

DECLARE Score : INTEGER
DECLARE Grade : CHAR

OUTPUT "Enter score (0-100):"
INPUT Score

IF Score >= 90 THEN
    Grade <- 'A'
ELSEIF Score >= 80 THEN
    Grade <- 'B'
ELSEIF Score >= 70 THEN
    Grade <- 'C'
ELSEIF Score >= 60 THEN
    Grade <- 'D'
ELSE
    Grade <- 'F'
ENDIF

OUTPUT "Your grade is: ", Grade

DECLARE Choice : CHAR

OUTPUT "=== Menu ==="
OUTPUT "A - Add"
OUTPUT "S - Subtract"
OUTPUT "M - Multiply"
OUTPUT "D - Divide"
OUTPUT "Enter choice:"
INPUT Choice

CASE OF Choice
    'A' :
        OUTPUT "Addition selected"
    'S' :
        OUTPUT "Subtraction selected"
    'M' :
        OUTPUT "Multiplication selected"
    'D' :
        OUTPUT "Division selected"
    OTHERWISE:
        OUTPUT "Invalid choice"
ENDCASE

DECLARE i : INTEGER

OUTPUT "Counting 1 to 10:"
FOR i <- 1 TO 10
    OUTPUT i
NEXT i

DECLARE i : INTEGER

OUTPUT "Counting down from 10 to 1:"
FOR i <- 10 TO 1 STEP -1
    OUTPUT i
NEXT i

OUTPUT ""
OUTPUT "Even numbers from 2 to 20:"
FOR i <- 2 TO 20 STEP 2
    OUTPUT i
NEXT i

DECLARE Count : INTEGER

Count <- 1
WHILE Count <= 5 DO
    OUTPUT Count
    Count <- Count + 1
ENDWHILE

DECLARE Password : STRING

REPEAT
    OUTPUT "Enter password:"
    INPUT Password
    IF Password <> "secret" THEN
        OUTPUT "Incorrect! Try again."
    ENDIF
UNTIL Password = "secret"

OUTPUT "Access granted!"

DECLARE Number : INTEGER
DECLARE Guess : INTEGER
DECLARE Count : INTEGER

Number <- INT(RANDOM() * 10) + 1
Count <- 0

OUTPUT "Guess a number between 1 and 10"

REPEAT
    INPUT Guess
    Count <- Count + 1

    IF Guess < Number THEN
        OUTPUT "Too low!"
    ELSEIF Guess > Number THEN
        OUTPUT "Too high!"
    ENDIF
UNTIL Guess = Number

OUTPUT "Correct! You got it in ", Count, " guesses!"

DECLARE Numbers : ARRAY[1:5] OF INTEGER
DECLARE i : INTEGER

OUTPUT "Enter 5 numbers:"
FOR i <- 1 TO 5
    INPUT Numbers[i]
NEXT i

OUTPUT "You entered:"
FOR i <- 1 TO 5
    OUTPUT Numbers[i]
NEXT i

DECLARE Numbers : ARRAY[1:5] OF INTEGER
DECLARE i : INTEGER
DECLARE Max : INTEGER

OUTPUT "Enter 5 numbers:"
FOR i <- 1 TO 5
    INPUT Numbers[i]
NEXT i

Max <- Numbers[1]
FOR i <- 2 TO 5
    IF Numbers[i] > Max THEN
        Max <- Numbers[i]
    ENDIF
NEXT i

OUTPUT "Maximum: ", Max

// Seed the accumulators with the INFINITY constant so the
// very first array value always replaces them. INFINITY is a
// REAL value; put a minus sign in front for negative infinity.
DECLARE Numbers : ARRAY[1:8] OF INTEGER
DECLARE i : INTEGER
DECLARE Smallest : REAL
DECLARE Largest : REAL

// Sample data
Numbers[1] <- 42
Numbers[2] <- 17
Numbers[3] <- 89
Numbers[4] <- 6
Numbers[5] <- 55
Numbers[6] <- 31
Numbers[7] <- 74
Numbers[8] <- 23

Smallest <- INFINITY      // nothing is bigger than +infinity
Largest <- -INFINITY      // nothing is smaller than -infinity

FOR i <- 1 TO 8
    IF Numbers[i] < Smallest THEN
        Smallest <- Numbers[i]
    ENDIF
    IF Numbers[i] > Largest THEN
        Largest <- Numbers[i]
    ENDIF
NEXT i

OUTPUT "Smallest: ", Smallest
OUTPUT "Largest:  ", Largest
OUTPUT "Range:    ", Largest - Smallest

DECLARE Scores : ARRAY[1:5] OF INTEGER
DECLARE i : INTEGER
DECLARE Total : INTEGER
DECLARE Average : REAL

Total <- 0

OUTPUT "Enter 5 scores:"
FOR i <- 1 TO 5
    INPUT Scores[i]
    Total <- Total + Scores[i]
NEXT i

Average <- Total / 5.0
OUTPUT "Average score: ", ROUND(Average, 2)

DECLARE Grid : ARRAY[1:3, 1:3] OF CHAR
DECLARE i : INTEGER
DECLARE j : INTEGER

// Initialize grid
FOR i <- 1 TO 3
    FOR j <- 1 TO 3
        Grid[i,j] <- '-'
    NEXT j
NEXT i

// Place some values
Grid[1,1] <- 'X'
Grid[2,2] <- 'O'
Grid[3,3] <- 'X'

// Display grid
OUTPUT "Grid:"
FOR i <- 1 TO 3
    FOR j <- 1 TO 3
        OUTPUT Grid[i,j], " "
    NEXT j
    OUTPUT ""
NEXT i

DECLARE Text : STRING

OUTPUT "Enter your name:"
INPUT Text

OUTPUT "Length: ", LENGTH(Text)
OUTPUT "Uppercase: ", UCASE(Text)
OUTPUT "Lowercase: ", LCASE(Text)
OUTPUT "First 3 chars: ", SUBSTRING(Text, 1, 3)
OUTPUT "Left 2 chars: ", LEFT(Text, 2)
OUTPUT "Right 2 chars: ", RIGHT(Text, 2)

DECLARE FirstName : STRING
DECLARE LastName : STRING
DECLARE FullName : STRING

OUTPUT "Enter first name:"
INPUT FirstName
OUTPUT "Enter last name:"
INPUT LastName

FullName <- FirstName & " " & LastName
OUTPUT "Full name: ", FullName

// Create email
DECLARE Email : STRING
Email <- LCASE(FirstName) & "." & LCASE(LastName) & "@school.edu"
OUTPUT "Email: ", Email

PROCEDURE Greet(Name : STRING)
    OUTPUT "Hello, ", Name, "!"
ENDPROCEDURE

DECLARE UserName : STRING

OUTPUT "Enter your name:"
INPUT UserName

CALL Greet(UserName)

FUNCTION Square(N : INTEGER) RETURNS INTEGER
    RETURN N * N
ENDFUNCTION

DECLARE Num : INTEGER

OUTPUT "Enter a number:"
INPUT Num

OUTPUT "Square of ", Num, " is ", Square(Num)

FUNCTION Factorial(N : INTEGER) RETURNS INTEGER
    DECLARE Result : INTEGER
    DECLARE i : INTEGER

    Result <- 1
    FOR i <- 1 TO N
        Result <- Result * i
    NEXT i

    RETURN Result
ENDFUNCTION

DECLARE Number : INTEGER

OUTPUT "Enter a number:"
INPUT Number

OUTPUT "Factorial of ", Number, " is ", Factorial(Number)

// Write student scores to a file
DECLARE Name : STRING
DECLARE Score : INTEGER
DECLARE i : INTEGER

OPENFILE "scores.txt" FOR WRITE

FOR i <- 1 TO 3
    OUTPUT "Enter student ", i, " name:"
    INPUT Name
    OUTPUT "Enter score:"
    INPUT Score

    WRITEFILE "scores.txt", Name & "," & NUM_TO_STRING(Score)
NEXT i

CLOSEFILE "scores.txt"

OUTPUT "Data saved to scores.txt"

// Read and display all lines from file
DECLARE Line : STRING

OUTPUT "Reading from scores.txt:"
OUTPUT ""

OPENFILE "scores.txt" FOR READ

WHILE NOT EOF("scores.txt") DO
    READFILE "scores.txt", Line
    OUTPUT Line
ENDWHILE

CLOSEFILE "scores.txt"

OUTPUT ""
OUTPUT "File read complete"

// Add more data to existing file
DECLARE Name : STRING
DECLARE Score : INTEGER

OUTPUT "Add a new student"
OUTPUT "Enter name:"
INPUT Name
OUTPUT "Enter score:"
INPUT Score

OPENFILE "scores.txt" FOR APPEND
WRITEFILE "scores.txt", Name & "," & NUM_TO_STRING(Score)
CLOSEFILE "scores.txt"

OUTPUT "New student added to file"

DECLARE Number : REAL

OUTPUT "Enter a decimal number:"
INPUT Number

OUTPUT "Original: ", Number
OUTPUT "Rounded (0 places): ", ROUND(Number, 0)
OUTPUT "Rounded (2 places): ", ROUND(Number, 2)
OUTPUT "Integer part: ", INT(Number)

OUTPUT ""
OUTPUT "Random number (0-1): ", RANDOM()
OUTPUT "Random 1-10: ", INT(RANDOM() * 10) + 1
OUTPUT "Random 1-100: ", INT(RANDOM() * 100) + 1

DECLARE Celsius : REAL
DECLARE Fahrenheit : REAL

OUTPUT "Enter temperature in Celsius:"
INPUT Celsius

Fahrenheit <- (Celsius * 9.0 / 5.0) + 32.0

OUTPUT Celsius, "°C = ", ROUND(Fahrenheit, 2), "°F"

DECLARE NumText : STRING
DECLARE Number : INTEGER
DECLARE Ch : CHAR

OUTPUT "Enter a number as text:"
INPUT NumText

IF IS_NUM(NumText) = TRUE THEN
    Number <- STRING_TO_NUM(NumText)
    OUTPUT "Number value: ", Number
    OUTPUT "Double: ", Number * 2
ELSE
    OUTPUT "Not a valid number"
ENDIF

OUTPUT ""
OUTPUT "Enter a character:"
INPUT Ch
OUTPUT "ASCII code: ", ASC(Ch)
OUTPUT "Character from code 65: ", CHR(65)

DECLARE Names : ARRAY[1:5] OF STRING
DECLARE Scores : ARRAY[1:5] OF INTEGER
DECLARE i : INTEGER
DECLARE Total : INTEGER
DECLARE Average : REAL

OUTPUT "=== Student Grade Manager ==="
OUTPUT ""

// Input
FOR i <- 1 TO 5
    OUTPUT "Student ", i, " name:"
    INPUT Names[i]
    OUTPUT "Student ", i, " score:"
    INPUT Scores[i]
NEXT i

// Calculate average
Total <- 0
FOR i <- 1 TO 5
    Total <- Total + Scores[i]
NEXT i
Average <- Total / 5.0

// Display results
OUTPUT ""
OUTPUT "=== Results ==="
FOR i <- 1 TO 5
    OUTPUT Names[i], ": ", Scores[i]
NEXT i

OUTPUT ""
OUTPUT "Class average: ", ROUND(Average, 2)

DECLARE Num1 : REAL
DECLARE Num2 : REAL
DECLARE Op : CHAR
DECLARE Result : REAL

OUTPUT "Enter first number:"
INPUT Num1

OUTPUT "Enter operator (+, -, *, /):"
INPUT Op

OUTPUT "Enter second number:"
INPUT Num2

CASE OF Op
    '+' :
        Result <- Num1 + Num2
    '-' :
        Result <- Num1 - Num2
    '*' :
        Result <- Num1 * Num2
    '/' :
        IF Num2 = 0 THEN
            OUTPUT "Error: Division by zero"
        ELSE
            Result <- Num1 / Num2
        ENDIF
    OTHERWISE:
        OUTPUT "Invalid operator"
ENDCASE

IF Op = '+' OR Op = '-' OR Op = '*' OR (Op = '/' AND Num2 <> 0) THEN
    OUTPUT Num1, " ", Op, " ", Num2, " = ", Result
ENDIF

DECLARE Numbers : ARRAY[1:10] OF INTEGER
DECLARE i : INTEGER
DECLARE Target : INTEGER
DECLARE Found : BOOLEAN
DECLARE Position : INTEGER

// Initialize array
Numbers[1] <- 34
Numbers[2] <- 78
Numbers[3] <- 12
Numbers[4] <- 56
Numbers[5] <- 90
Numbers[6] <- 23
Numbers[7] <- 45
Numbers[8] <- 67
Numbers[9] <- 89
Numbers[10] <- 11

OUTPUT "Array contents:"
FOR i <- 1 TO 10
    OUTPUT Numbers[i], " "
NEXT i

OUTPUT ""
OUTPUT "Enter number to search:"
INPUT Target

Found <- FALSE
Position <- -1

FOR i <- 1 TO 10
    IF Numbers[i] = Target THEN
        Found <- TRUE
        Position <- i
    ENDIF
NEXT i

IF Found = TRUE THEN
    OUTPUT "Found at position ", Position
ELSE
    OUTPUT "Not found"
ENDIF

DECLARE Numbers : ARRAY[1:10] OF INTEGER
DECLARE Target : INTEGER
DECLARE Low : INTEGER
DECLARE High : INTEGER
DECLARE Mid : INTEGER
DECLARE Found : BOOLEAN
DECLARE i : INTEGER

// Sorted array required for binary search
Numbers[1] <- 11
Numbers[2] <- 23
Numbers[3] <- 34
Numbers[4] <- 45
Numbers[5] <- 56
Numbers[6] <- 67
Numbers[7] <- 78
Numbers[8] <- 89
Numbers[9] <- 90
Numbers[10] <- 95

OUTPUT "Sorted array:"
FOR i <- 1 TO 10
    OUTPUT Numbers[i], " "
NEXT i

OUTPUT ""
OUTPUT "Enter number to search:"
INPUT Target

Low <- 1
High <- 10
Found <- FALSE

WHILE Low <= High AND Found = FALSE DO
    Mid <- INT((Low + High) / 2)
    
    IF Numbers[Mid] = Target THEN
        Found <- TRUE
        OUTPUT "Found at position ", Mid
    ELSEIF Numbers[Mid] < Target THEN
        Low <- Mid + 1
    ELSE
        High <- Mid - 1
    ENDIF
ENDWHILE

IF Found = FALSE THEN
    OUTPUT "Not found"
ENDIF

DECLARE Numbers : ARRAY[1:8] OF INTEGER
DECLARE i : INTEGER
DECLARE j : INTEGER
DECLARE Temp : INTEGER
DECLARE Swapped : BOOLEAN

// Initialize unsorted array
Numbers[1] <- 64
Numbers[2] <- 34
Numbers[3] <- 25
Numbers[4] <- 12
Numbers[5] <- 22
Numbers[6] <- 11
Numbers[7] <- 90
Numbers[8] <- 88

OUTPUT "Before sorting:"
FOR i <- 1 TO 8
    OUTPUT Numbers[i], " "
NEXT i

// Bubble Sort algorithm
FOR i <- 1 TO 7
    Swapped <- FALSE
    FOR j <- 1 TO 8 - i
        IF Numbers[j] > Numbers[j + 1] THEN
            // Swap
            Temp <- Numbers[j]
            Numbers[j] <- Numbers[j + 1]
            Numbers[j + 1] <- Temp
            Swapped <- TRUE
        ENDIF
    NEXT j
    
    // Early exit if no swaps
    IF Swapped = FALSE THEN
        i <- 7
    ENDIF
NEXT i

OUTPUT ""
OUTPUT "After sorting:"
FOR i <- 1 TO 8
    OUTPUT Numbers[i], " "
NEXT i

DECLARE Numbers : ARRAY[1:8] OF INTEGER
DECLARE i : INTEGER
DECLARE j : INTEGER
DECLARE MinIndex : INTEGER
DECLARE Temp : INTEGER

// Initialize unsorted array
Numbers[1] <- 64
Numbers[2] <- 25
Numbers[3] <- 12
Numbers[4] <- 22
Numbers[5] <- 11
Numbers[6] <- 90
Numbers[7] <- 88
Numbers[8] <- 34

OUTPUT "Before sorting:"
FOR i <- 1 TO 8
    OUTPUT Numbers[i], " "
NEXT i

// Selection Sort algorithm
FOR i <- 1 TO 7
    MinIndex <- i
    
    // Find minimum in unsorted portion
    FOR j <- i + 1 TO 8
        IF Numbers[j] < Numbers[MinIndex] THEN
            MinIndex <- j
        ENDIF
    NEXT j
    
    // Swap if needed
    IF MinIndex <> i THEN
        Temp <- Numbers[i]
        Numbers[i] <- Numbers[MinIndex]
        Numbers[MinIndex] <- Temp
    ENDIF
NEXT i

OUTPUT ""
OUTPUT "After sorting:"
FOR i <- 1 TO 8
    OUTPUT Numbers[i], " "
NEXT i

DECLARE Numbers : ARRAY[1:8] OF INTEGER
DECLARE i : INTEGER
DECLARE j : INTEGER
DECLARE Key : INTEGER

// Initialize unsorted array
Numbers[1] <- 64
Numbers[2] <- 25
Numbers[3] <- 12
Numbers[4] <- 22
Numbers[5] <- 11
Numbers[6] <- 90
Numbers[7] <- 88
Numbers[8] <- 34

OUTPUT "Before sorting:"
FOR i <- 1 TO 8
    OUTPUT Numbers[i], " "
NEXT i

// Insertion Sort algorithm
FOR i <- 2 TO 8
    Key <- Numbers[i]
    j <- i - 1
    
    WHILE j >= 1 AND Numbers[j] > Key DO
        Numbers[j + 1] <- Numbers[j]
        j <- j - 1
    ENDWHILE
    
    Numbers[j + 1] <- Key
NEXT i

OUTPUT ""
OUTPUT "After sorting:"
FOR i <- 1 TO 8
    OUTPUT Numbers[i], " "
NEXT i

DECLARE Number : INTEGER
DECLARE i : INTEGER
DECLARE IsPrime : BOOLEAN

OUTPUT "Enter a number:"
INPUT Number

IF Number < 2 THEN
    OUTPUT Number, " is not a prime number"
ELSE
    IsPrime <- TRUE
    
    FOR i <- 2 TO INT(Number / 2)
        IF MOD(Number, i) = 0 THEN
            IsPrime <- FALSE
        ENDIF
    NEXT i
    
    IF IsPrime = TRUE THEN
        OUTPUT Number, " is a prime number"
    ELSE
        OUTPUT Number, " is not a prime number"
    ENDIF
ENDIF

DECLARE Start : INTEGER
DECLARE Finish : INTEGER
DECLARE Number : INTEGER
DECLARE i : INTEGER
DECLARE IsPrime : BOOLEAN
DECLARE Count : INTEGER

OUTPUT "Enter start of range:"
INPUT Start
OUTPUT "Enter end of range:"
INPUT Finish

OUTPUT "Prime numbers between ", Start, " and ", Finish, ":"
Count <- 0

FOR Number <- Start TO Finish
    IF Number >= 2 THEN
        IsPrime <- TRUE
        
        FOR i <- 2 TO INT(Number / 2)
            IF MOD(Number, i) = 0 THEN
                IsPrime <- FALSE
            ENDIF
        NEXT i
        
        IF IsPrime = TRUE THEN
            OUTPUT Number, " "
            Count <- Count + 1
        ENDIF
    ENDIF
NEXT Number

OUTPUT ""
OUTPUT "Total: ", Count, " prime numbers"

DECLARE N : INTEGER
DECLARE First : INTEGER
DECLARE Second : INTEGER
DECLARE NextTerm : INTEGER
DECLARE i : INTEGER

OUTPUT "How many Fibonacci numbers?"
INPUT N

OUTPUT "Fibonacci sequence:"

First <- 0
Second <- 1

IF N >= 1 THEN
    OUTPUT First, " "
ENDIF

IF N >= 2 THEN
    OUTPUT Second, " "
ENDIF

FOR i <- 3 TO N
    NextTerm <- First + Second
    OUTPUT NextTerm, " "
    First <- Second
    Second <- NextTerm
NEXT i

DECLARE A : INTEGER
DECLARE B : INTEGER
DECLARE Temp : INTEGER

OUTPUT "Enter first number:"
INPUT A
OUTPUT "Enter second number:"
INPUT B

// Euclidean algorithm
WHILE B <> 0 DO
    Temp <- B
    B <- MOD(A, B)
    A <- Temp
ENDWHILE

OUTPUT "GCD: ", A

DECLARE Number : INTEGER
DECLARE Factorial : INTEGER
DECLARE i : INTEGER

OUTPUT "Enter a number:"
INPUT Number

IF Number < 0 THEN
    OUTPUT "Factorial not defined for negative numbers"
ELSE
    Factorial <- 1
    
    FOR i <- 1 TO Number
        Factorial <- Factorial * i
    NEXT i
    
    OUTPUT "Factorial of ", Number, " is ", Factorial
ENDIF

DECLARE Text : STRING
DECLARE Reversed : STRING
DECLARE i : INTEGER
DECLARE Len : INTEGER

OUTPUT "Enter a word:"
INPUT Text

Len <- LENGTH(Text)
Reversed <- ""

FOR i <- Len TO 1 STEP -1
    Reversed <- Reversed & SUBSTRING(Text, i, 1)
NEXT i

OUTPUT "Original: ", Text
OUTPUT "Reversed: ", Reversed

IF LCASE(Text) = LCASE(Reversed) THEN
    OUTPUT "It is a palindrome!"
ELSE
    OUTPUT "Not a palindrome"
ENDIF

DECLARE Text : STRING
DECLARE i : INTEGER
DECLARE Ch : CHAR
DECLARE VowelCount : INTEGER
DECLARE Len : INTEGER

OUTPUT "Enter a sentence:"
INPUT Text

VowelCount <- 0
Len <- LENGTH(Text)

FOR i <- 1 TO Len
    Ch <- LCASE(SUBSTRING(Text, i, 1))
    
    IF Ch = 'a' OR Ch = 'e' OR Ch = 'i' OR Ch = 'o' OR Ch = 'u' THEN
        VowelCount <- VowelCount + 1
    ENDIF
NEXT i

OUTPUT "Number of vowels: ", VowelCount

DECLARE Text : STRING
DECLARE Result : STRING
DECLARE CurrentWord : STRING
DECLARE i : INTEGER
DECLARE Ch : STRING
DECLARE Len : INTEGER

OUTPUT "Enter a sentence:"
INPUT Text

Result <- ""
CurrentWord <- ""
Len <- LENGTH(Text)

FOR i <- Len TO 1 STEP -1
    Ch <- SUBSTRING(Text, i, 1)
    
    IF Ch = " " THEN
        IF LENGTH(CurrentWord) > 0 THEN
            Result <- Result & CurrentWord & " "
            CurrentWord <- ""
        ENDIF
    ELSE
        CurrentWord <- Ch & CurrentWord
    ENDIF
NEXT i

// Add last word
IF LENGTH(CurrentWord) > 0 THEN
    Result <- Result & CurrentWord
ENDIF

OUTPUT "Original: ", Text
OUTPUT "Reversed words: ", Result

DECLARE Numbers : ARRAY[1:8] OF INTEGER
DECLARE i : INTEGER
DECLARE Largest : INTEGER
DECLARE SecondLargest : INTEGER

// Initialize array
Numbers[1] <- 45
Numbers[2] <- 23
Numbers[3] <- 89
Numbers[4] <- 12
Numbers[5] <- 67
Numbers[6] <- 34
Numbers[7] <- 78
Numbers[8] <- 56

OUTPUT "Array:"
FOR i <- 1 TO 8
    OUTPUT Numbers[i], " "
NEXT i

Largest <- Numbers[1]
SecondLargest <- Numbers[1]

FOR i <- 2 TO 8
    IF Numbers[i] > Largest THEN
        SecondLargest <- Largest
        Largest <- Numbers[i]
    ELSEIF Numbers[i] > SecondLargest AND Numbers[i] <> Largest THEN
        SecondLargest <- Numbers[i]
    ENDIF
NEXT i

OUTPUT ""
OUTPUT "Largest: ", Largest
OUTPUT "Second Largest: ", SecondLargest

DECLARE Numbers : ARRAY[1:10] OF INTEGER
DECLARE Unique : ARRAY[1:10] OF INTEGER
DECLARE i : INTEGER
DECLARE j : INTEGER
DECLARE UniqueCount : INTEGER
DECLARE IsDuplicate : BOOLEAN

// Initialize array with duplicates
Numbers[1] <- 5
Numbers[2] <- 3
Numbers[3] <- 5
Numbers[4] <- 7
Numbers[5] <- 3
Numbers[6] <- 9
Numbers[7] <- 7
Numbers[8] <- 5
Numbers[9] <- 2
Numbers[10] <- 9

OUTPUT "Original array:"
FOR i <- 1 TO 10
    OUTPUT Numbers[i], " "
NEXT i

UniqueCount <- 0

FOR i <- 1 TO 10
    IsDuplicate <- FALSE
    
    // Check if already in unique array
    FOR j <- 1 TO UniqueCount
        IF Numbers[i] = Unique[j] THEN
            IsDuplicate <- TRUE
        ENDIF
    NEXT j
    
    // Add if not duplicate
    IF IsDuplicate = FALSE THEN
        UniqueCount <- UniqueCount + 1
        Unique[UniqueCount] <- Numbers[i]
    ENDIF
NEXT i

OUTPUT ""
OUTPUT "Unique values:"
FOR i <- 1 TO UniqueCount
    OUTPUT Unique[i], " "
NEXT i

DECLARE Array1 : ARRAY[1:5] OF INTEGER
DECLARE Array2 : ARRAY[1:5] OF INTEGER
DECLARE Merged : ARRAY[1:10] OF INTEGER
DECLARE i : INTEGER
DECLARE j : INTEGER
DECLARE k : INTEGER

// Initialize sorted arrays
Array1[1] <- 1
Array1[2] <- 3
Array1[3] <- 5
Array1[4] <- 7
Array1[5] <- 9

Array2[1] <- 2
Array2[2] <- 4
Array2[3] <- 6
Array2[4] <- 8
Array2[5] <- 10

OUTPUT "Array 1:"
FOR i <- 1 TO 5
    OUTPUT Array1[i], " "
NEXT i

OUTPUT ""
OUTPUT "Array 2:"
FOR i <- 1 TO 5
    OUTPUT Array2[i], " "
NEXT i

// Merge arrays
i <- 1
j <- 1
k <- 1

WHILE i <= 5 AND j <= 5 DO
    IF Array1[i] <= Array2[j] THEN
        Merged[k] <- Array1[i]
        i <- i + 1
    ELSE
        Merged[k] <- Array2[j]
        j <- j + 1
    ENDIF
    k <- k + 1
ENDWHILE

// Copy remaining elements
WHILE i <= 5 DO
    Merged[k] <- Array1[i]
    i <- i + 1
    k <- k + 1
ENDWHILE

WHILE j <= 5 DO
    Merged[k] <- Array2[j]
    j <- j + 1
    k <- k + 1
ENDWHILE

OUTPUT ""
OUTPUT "Merged array:"
FOR i <- 1 TO 10
    OUTPUT Merged[i], " "
NEXT i

// A record groups related data under one identifier
TYPE StudentRecord
    DECLARE LastName : STRING
    DECLARE FirstName : STRING
    DECLARE YearGroup : INTEGER
    DECLARE FormGroup : CHAR
ENDTYPE

DECLARE Pupil1 : StudentRecord
DECLARE Pupil2 : StudentRecord

Pupil1.LastName <- "Johnson"
Pupil1.FirstName <- "Leroy"
Pupil1.YearGroup <- 6
Pupil1.FormGroup <- 'A'

// Records are copied by value
Pupil2 <- Pupil1
Pupil2.FirstName <- "Leona"

OUTPUT Pupil1.FirstName, " ", Pupil1.LastName, " (", Pupil1.YearGroup, Pupil1.FormGroup, ")"
OUTPUT Pupil2.FirstName, " ", Pupil2.LastName, " (", Pupil2.YearGroup, Pupil2.FormGroup, ")"

// Enumerated type: a fixed list of named values
TYPE Season = (Spring, Summer, Autumn, Winter)

// Pointer type: holds the address of another variable
TYPE TSeasonPointer = ^Season

DECLARE ThisSeason : Season
DECLARE NextSeason : Season
DECLARE MyPointer : TSeasonPointer

ThisSeason <- Spring
MyPointer <- ^ThisSeason       // ^ takes the address of ThisSeason

// MyPointer^ reads the value at the address; + 1 moves to the next enum value
NextSeason <- MyPointer^ + 1

OUTPUT "This season: ", ThisSeason
OUTPUT "Next season: ", NextSeason

// Writing through the pointer changes ThisSeason itself
MyPointer^ <- Winter
OUTPUT "Now: ", ThisSeason

// BYREF passes a reference: the procedure changes the caller's variables.
// BYREF applies to the following parameters too, until BYVAL appears.
PROCEDURE SWAP(BYREF X : INTEGER, Y : INTEGER)
    DECLARE Temp : INTEGER
    Temp <- X
    X <- Y
    Y <- Temp
ENDPROCEDURE

DECLARE a : INTEGER
DECLARE b : INTEGER
a <- 1
b <- 2

OUTPUT "Before: a = ", a, ", b = ", b
CALL SWAP(a, b)
OUTPUT "After:  a = ", a, ", b = ", b

DECLARE Mark : INTEGER
OUTPUT "Enter a mark (0-100):"
INPUT Mark

CASE OF Mark
    80 TO 100 : OUTPUT "Grade A"
    60 TO 79  : OUTPUT "Grade B"
    40 TO 59  : OUTPUT "Grade C"
    OTHERWISE : OUTPUT "Ungraded"
ENDCASE

// Random files store fixed records at numbered positions
TYPE Student
    DECLARE Name : STRING
    DECLARE YearGroup : INTEGER
ENDTYPE

DECLARE Pupil : Student
DECLARE Found : Student

Pupil.Name <- "Leroy Johnson"
Pupil.YearGroup <- 6

OPENFILE "StudentFile.dat" FOR RANDOM
SEEK "StudentFile.dat", 10            // move the file pointer to position 10
PUTRECORD "StudentFile.dat", Pupil    // write the record there
CLOSEFILE "StudentFile.dat"

OPENFILE "StudentFile.dat" FOR RANDOM
SEEK "StudentFile.dat", 10
GETRECORD "StudentFile.dat", Found    // read the record back
CLOSEFILE "StudentFile.dat"

OUTPUT "Found: ", Found.Name, " (Year ", Found.YearGroup, ")"

CLASS Pet
    PRIVATE Name : STRING

    PUBLIC PROCEDURE NEW(GivenName : STRING)
        Name <- GivenName
    ENDPROCEDURE

    PUBLIC FUNCTION GetName() RETURNS STRING
        RETURN Name
    ENDFUNCTION
ENDCLASS

CLASS Cat INHERITS Pet
    PRIVATE Breed : STRING

    PUBLIC PROCEDURE NEW(GivenName : STRING, GivenBreed : STRING)
        SUPER.NEW(GivenName)          // call the parent constructor
        Breed <- GivenBreed
    ENDPROCEDURE

    PUBLIC FUNCTION Describe() RETURNS STRING
        RETURN GetName() & " is a " & Breed & " cat"
    ENDFUNCTION
ENDCLASS

MyCat <- NEW Cat("Kitty", "Shorthaired")
OUTPUT MyCat.Describe()

// LIFO stack: Top is the index of the last item pushed. Empty = -1.
DECLARE StackData : ARRAY[0:4] OF INTEGER
DECLARE Top : INTEGER

FUNCTION Push(Value : INTEGER) RETURNS BOOLEAN
    IF Top = 4 THEN
        RETURN FALSE
    ENDIF
    Top <- Top + 1
    StackData[Top] <- Value
    RETURN TRUE
ENDFUNCTION

FUNCTION Pop() RETURNS INTEGER
    DECLARE Value : INTEGER
    IF Top = -1 THEN
        RETURN -1
    ENDIF
    Value <- StackData[Top]
    Top <- Top - 1
    RETURN Value
ENDFUNCTION

Top <- -1
OUTPUT "Push 10: ", Push(10)
OUTPUT "Push 20: ", Push(20)
OUTPUT "Push 30: ", Push(30)
OUTPUT "Pop: ", Pop()
OUTPUT "Pop: ", Pop()
OUTPUT "Pop: ", Pop()
OUTPUT "Pop empty: ", Pop()

// FIFO linear queue. Head/Tail start at -1. Full when Tail reaches the last index.
DECLARE QueueData : ARRAY[0:4] OF STRING
DECLARE QueueHead, QueueTail : INTEGER

FUNCTION Enqueue(Value : STRING) RETURNS BOOLEAN
    IF QueueTail = 4 THEN
        RETURN FALSE
    ENDIF
    IF QueueHead = -1 THEN
        QueueHead <- 0
    ENDIF
    QueueTail <- QueueTail + 1
    QueueData[QueueTail] <- Value
    RETURN TRUE
ENDFUNCTION

FUNCTION Dequeue() RETURNS STRING
    DECLARE Item : STRING
    IF QueueHead = -1 OR QueueHead > QueueTail THEN
        RETURN "false"
    ENDIF
    Item <- QueueData[QueueHead]
    QueueHead <- QueueHead + 1
    RETURN Item
ENDFUNCTION

QueueHead <- -1
QueueTail <- -1
OUTPUT "Enqueue A: ", Enqueue("A")
OUTPUT "Enqueue B: ", Enqueue("B")
OUTPUT "Enqueue C: ", Enqueue("C")
OUTPUT "Dequeue: ", Dequeue()
OUTPUT "Dequeue: ", Dequeue()
OUTPUT "Dequeue: ", Dequeue()
OUTPUT "Dequeue empty: ", Dequeue()

// Circular queue of 4 slots. Count tells full from empty when Head = Tail.
DECLARE QueueData : ARRAY[0:3] OF STRING
DECLARE Head, Tail, Count : INTEGER

FUNCTION Enqueue(Value : STRING) RETURNS BOOLEAN
    IF Count = 4 THEN
        RETURN FALSE
    ENDIF
    QueueData[Tail] <- Value
    Tail <- MOD(Tail + 1, 4)
    Count <- Count + 1
    RETURN TRUE
ENDFUNCTION

FUNCTION Dequeue() RETURNS STRING
    DECLARE Item : STRING
    IF Count = 0 THEN
        RETURN "false"
    ENDIF
    Item <- QueueData[Head]
    Head <- MOD(Head + 1, 4)
    Count <- Count - 1
    RETURN Item
ENDFUNCTION

Head <- 0
Tail <- 0
Count <- 0

OUTPUT Enqueue("A")
OUTPUT Enqueue("B")
OUTPUT Enqueue("C")
OUTPUT Enqueue("D")
OUTPUT "Full reject: ", Enqueue("X")
OUTPUT "Out: ", Dequeue()
OUTPUT "Out: ", Dequeue()
OUTPUT Enqueue("E")
OUTPUT Enqueue("F")
OUTPUT "Out: ", Dequeue()
OUTPUT "Out: ", Dequeue()
OUTPUT "Out: ", Dequeue()
OUTPUT "Out: ", Dequeue()

// Paper 4 style: LinkedList[i, 0] = data, LinkedList[i, 1] = next index.
// Unused nodes are chained from StartEmptyList. Null pointer = -1.
DECLARE LinkedList : ARRAY[0:4, 0:1] OF INTEGER
DECLARE StartLinkedList, StartEmptyList : INTEGER

PROCEDURE PrintList()
    DECLARE Current : INTEGER
    Current <- StartLinkedList
    WHILE Current <> -1 DO
        OUTPUT LinkedList[Current, 0]
        Current <- LinkedList[Current, 1]
    ENDWHILE
ENDPROCEDURE

PROCEDURE AddItem(Value : INTEGER)
    DECLARE NewNode, Current : INTEGER
    IF StartEmptyList = -1 THEN
        OUTPUT "List is full"
    ELSE
        NewNode <- StartEmptyList
        StartEmptyList <- LinkedList[StartEmptyList, 1]
        LinkedList[NewNode, 0] <- Value
        LinkedList[NewNode, 1] <- -1
        IF StartLinkedList = -1 THEN
            StartLinkedList <- NewNode
        ELSE
            Current <- StartLinkedList
            WHILE LinkedList[Current, 1] <> -1 DO
                Current <- LinkedList[Current, 1]
            ENDWHILE
            LinkedList[Current, 1] <- NewNode
        ENDIF
    ENDIF
ENDPROCEDURE

// Initial list: 10 → 20 → 30 at indices 0, 1, 2. Free chain: 3 → 4.
LinkedList[0, 0] <- 10
LinkedList[0, 1] <- 1
LinkedList[1, 0] <- 20
LinkedList[1, 1] <- 2
LinkedList[2, 0] <- 30
LinkedList[2, 1] <- -1
LinkedList[3, 0] <- -1
LinkedList[3, 1] <- 4
LinkedList[4, 0] <- -1
LinkedList[4, 1] <- -1
StartLinkedList <- 0
StartEmptyList <- 3

OUTPUT "Before:"
CALL PrintList()
CALL AddItem(40)
OUTPUT "After adding 40:"
CALL PrintList()

// Paper 4 style: Tree[i, 0] = left, Tree[i, 1] = data, Tree[i, 2] = right.
// Null pointer = -1. New nodes always come from FirstFree, then FirstFree + 1.
DECLARE Tree : ARRAY[0:9, 0:2] OF INTEGER
DECLARE RootPointer, FirstFree, Index : INTEGER

PROCEDURE AddNode(Value : INTEGER)
    DECLARE NewIndex, Current, Parent : INTEGER
    IF FirstFree > 9 THEN
        OUTPUT "The tree is full"
    ELSE
        NewIndex <- FirstFree
        Tree[NewIndex, 0] <- -1
        Tree[NewIndex, 1] <- Value
        Tree[NewIndex, 2] <- -1
        FirstFree <- FirstFree + 1
        IF RootPointer = -1 THEN
            RootPointer <- NewIndex
        ELSE
            Current <- RootPointer
            WHILE Current <> -1 DO
                Parent <- Current
                IF Value < Tree[Current, 1] THEN
                    Current <- Tree[Current, 0]
                ELSE
                    Current <- Tree[Current, 2]
                ENDIF
            ENDWHILE
            IF Value < Tree[Parent, 1] THEN
                Tree[Parent, 0] <- NewIndex
            ELSE
                Tree[Parent, 2] <- NewIndex
            ENDIF
        ENDIF
    ENDIF
ENDPROCEDURE

PROCEDURE InOrder(NodeIndex : INTEGER)
    IF NodeIndex <> -1 THEN
        CALL InOrder(Tree[NodeIndex, 0])
        OUTPUT Tree[NodeIndex, 1]
        CALL InOrder(Tree[NodeIndex, 2])
    ENDIF
ENDPROCEDURE

FOR Index <- 0 TO 9
    Tree[Index, 0] <- -1
    Tree[Index, 1] <- -1
    Tree[Index, 2] <- -1
NEXT Index
RootPointer <- -1
FirstFree <- 0

CALL AddNode(20)
CALL AddNode(10)
CALL AddNode(26)
CALL AddNode(22)
CALL AddNode(8)

OUTPUT "In-order (ascending):"
CALL InOrder(RootPointer)

// Hash = key MOD 10. Collisions sit in the next free slot of the same row.
DECLARE Keys : ARRAY[0:9, 0:2] OF INTEGER
DECLARE Values : ARRAY[0:9, 0:2] OF STRING
DECLARE Row, Slot : INTEGER

FUNCTION Hash(Key : INTEGER) RETURNS INTEGER
    RETURN MOD(Key, 10)
ENDFUNCTION

PROCEDURE InsertData(Key : INTEGER, Data : STRING)
    DECLARE Index, Col : INTEGER
    Index <- Hash(Key)
    Col <- 0
    WHILE Col <= 2 AND Keys[Index, Col] <> -1 DO
        Col <- Col + 1
    ENDWHILE
    IF Col <= 2 THEN
        Keys[Index, Col] <- Key
        Values[Index, Col] <- Data
    ENDIF
ENDPROCEDURE

FUNCTION GetRecord(Key : INTEGER) RETURNS STRING
    DECLARE Index, Col : INTEGER
    Index <- Hash(Key)
    FOR Col <- 0 TO 2
        IF Keys[Index, Col] = Key THEN
            RETURN Values[Index, Col]
        ENDIF
    NEXT Col
    RETURN "Not found"
ENDFUNCTION

FOR Row <- 0 TO 9
    FOR Slot <- 0 TO 2
        Keys[Row, Slot] <- -1
        Values[Row, Slot] <- ""
    NEXT Slot
NEXT Row

CALL InsertData(15, "alpha")
CALL InsertData(25, "bravo")
CALL InsertData(12, "charlie")

OUTPUT "15 → ", GetRecord(15)
OUTPUT "25 → ", GetRecord(25)
OUTPUT "12 → ", GetRecord(12)
OUTPUT "99 → ", GetRecord(99)