Step 1: Variables

Code:

Explanation:

1. Variable Declaration:
• DECLARE sum :INTEGER: Declares a variable named sum of type INTEGER.
• DECLARE name : STRING: Declares a variable named name of type STRING.
• DECLARE flag : BOOLEAN: Declares a variable named flag of type BOOLEAN.

2. Variable Initialization:
• sum <-- 100: Assigns the integer value 100 to sum.
• name <-- "Victor": Assigns the string "Victor" to name.
• flag <-- TRUE: Assigns the boolean value TRUE to flag.

3. Output Statements:
• OUTPUT sum: Displays the value of sum (which is 100).
• OUTPUT name: Displays the value of name (which is "Victor").
• OUTPUT flag: Displays the value of flag (which is TRUE).

Step 2: Simple Loop

Code:

Explanation:

1. Variable Declaration and Initialization:
• DECLARE sum :INTEGER: Declares an integer variable sum.
• sum <-- 0: Initializes sum to 0.

2. FOR Loop:
• FOR i <-- 1 TO 100: Initiates a loop where the variable i starts at 1 and increments by 1 each iteration until it reaches 100.
• sum <-- sum + i: In each iteration, adds the current value of i to sum.
• NEXT i: Marks the end of the loop block for the variable i.

3. Output Statement:
• OUTPUT sum: After the loop completes, outputs the final value of sum.

• This loop calculates the sum of all integers from 1 to 100. After the loop, sum will hold the value 5050, which is the result of 100*101/2.

Step 3: Loop with Step and While Loop

Code:

Explanation:

Part 1: FOR Loop with STEP

1. First Loop: Summing Odd Numbers
• DECLARE sum :INTEGER and sum <-- 0: Initializes sum to 0.
• FOR i <-- 1 TO 100 STEP 2: Starts a loop with i from 1 to 100, incrementing by 2 each time (i.e., 1, 3, 5, ..., 99).
• sum <-- sum + i: Adds the current odd number i to sum.
• OUTPUT sum: Outputs the total sum of odd numbers between 1 and 100. The result is 2500.

2. Second Loop: Summing Even Numbers
• DECLARE sum2 :INTEGER and sum2 <-- 0: Initializes sum2 to 0.
• FOR i <-- 0 TO 100 STEP 2: Starts a loop with i from 0 to 100, incrementing by 2 each time (i.e., 0, 2, 4, ..., 100).
• sum2 <-- sum2 + i: Adds the current even number i to sum2.
• OUTPUT sum2: Outputs the total sum of even numbers between 0 and 100. The result is 2550.

Part 2: WHILE Loop

1. Variable Declaration and Initialization:
• DECLARE target, generated, count : INTEGER: Declares three integer variables.
• target <-- 8: Sets the target number to 8.
• generated <-- INT(RAND(10)): Generates a random integer between 0 and 9 and assigns it to generated.
• count <-- 1: Initializes count to 1.

2. WHILE Loop:
• WHILE generated <> target DO: Continues looping as long as generated is not equal to target.
• OUTPUT generated: Outputs the currently generated number.
• generated <-- INT(RAND(10)): Generates a new random integer between 0 and 9.
• count <-- count + 1: Increments the count by 1.
• ENDWHILE: Marks the end of the loop.

3. Final Output:
• OUTPUT "Found target number ", target, " in ", count, " random guesses": After finding the target number, outputs a message indicating how many guesses it took to find the target.

• First Part: Demonstrates how to use a FOR loop with a step value to sum odd and even numbers separately.

• Second Part: Uses a WHILE loop to repeatedly generate random numbers until the target number (8) is found, keeping track of the number of attempts.

Step 4: PROCEDURE

Code:

Explanation:

1. Procedure Declaration:
• PROCEDURE Greetings(): Defines a procedure named Greetings that takes no parameters.

2. Procedure Body:
• FOR count <-- 1 TO 90: Initiates a loop that runs 90 times.
• OUTPUT "Hello": In each iteration, outputs the string "Hello".
• NEXT count: Marks the end of the loop block.

3. Procedure Call:
• Greetings(): Calls the Greetings procedure, executing its body.

• This procedure, when called, prints the word "Hello" ninety times. It's a way to encapsulate reusable code; you can call Greetings() wherever you need to perform this action without rewriting the loop each time.

Step 5: FUNCTION 1

Code:

Explanation:

1. Function Declaration:
• FUNCTION findArea(radius : REAL) RETURNS REAL: Defines a function named findArea that takes one parameter radius of type REAL (floating-point number) and returns a REAL value.

2. Function Body:
• CONSTANT pi = 3.1415962653: Declares a constant pi with its approximate value.
• DECLARE area : REAL: Declares a variable area of type REAL.
• area <-- pi * radius ** 2: Calculates the area of a circle using the formula \( \pi r^2 \) and assigns it to area. Here, * denotes exponentiation.
• RETURN area: Returns the calculated area.

3. Function Call and Output:
• OUTPUT findArea(100): Calls the findArea function with radius set to 100 and outputs the returned area.

• The findArea function calculates the area of a circle given its radius. In this example, it calculates the area for a circle with a radius of 100, resulting in \( \pi \times 100^2 = 31,415.92653 \).

Step 6: FUNCTION 2

Code:

Explanation:

1. Function Declaration:
• FUNCTION isPrime(n : INTEGER) RETURNS BOOLEAN: Defines a function named isPrime that takes an integer n and returns a boolean value (TRUE or FALSE).

2. Function Body:
• DECLARE max : INTEGER: Declares an integer variable max.
• max <-- INT(n ** 0.5): Calculates the integer part of the square root of n and assigns it to max. This is used to optimize the prime checking process.
• FOR count <-- 2 TO max: Starts a loop from 2 to max.
• IF n MOD count = 0 THEN: Checks if n is divisible by count without a remainder.
• RETURN FALSE: If n is divisible by any number between 2 and max, it is not prime; thus, returns FALSE.
• NEXT count: Ends the loop.
• RETURN TRUE: If no divisors are found, the number is prime; returns TRUE.

3. Function Call and Output:
• OUTPUT isPrime(18): Calls the isPrime function with n = 18 and outputs the result.

• The isPrime function determines whether a given integer n is a prime number.

• In the example, isPrime(18) checks if 18 is prime. Since 18 is divisible by 2, 3, 6, and 9, the function returns FALSE, indicating that 18 is not a prime number.

Step 7: Loops & Functions

Code:

Explanation:

1. FOR Loop:
• FOR n <-- 2 TO 1000: Initiates a loop where n ranges from 2 to 1000.
• IF isPrime(n) THEN: Calls the previously defined isPrime function to check if n is prime.
• OUTPUT "🟢 ", n, " is prime!": If n is prime, outputs a green circle emoji followed by the message that n is prime.
• ELSE: If n is not prime,
• OUTPUT "🔴 ", n, " is not prime...": Outputs a red circle emoji followed by the message that n is not prime.
• ENDIF: Ends the IF statement.
• NEXT n: Moves to the next value of n.

2. Function Definition:
• The isPrime function is the same as defined in Step 6. It checks whether a given number n is prime.

• This code iterates through all numbers from 2 to 1000, checks each number to see if it's prime using the isPrime function, and outputs a message indicating whether each umber is prime or not with corresponding emojis.

Step 8: Nested Loops

Code:

Explanation:

1. FOR Loop:
• FOR n <-- 3 TO 1000: Starts a loop with n ranging from 3 to 1000.

2. Nested IF Statements:
• IF isPrime(n) THEN: Checks if n is a prime number.
• IF isPrime(n+2) THEN: If n is prime, checks if n + 2 is also prime.
• OUTPUT "🟢🟢 ", n," and ",n+2, " are twin primes": If both n and n + 2 are prime, outputs a message indicating they are twin primes with two green circle emojis.
• ENDIF: Ends the inner IF.
• ENDIF: Ends the outer IF.
• NEXT n: Proceeds to the next value of n.

3. Function Definition:
• The isPrime function is the same as previously defined in Step 6 and Step 7.

• This code identifies and outputs all twin primes between 3 and 1000.

• Twin primes are pairs of prime numbers that have a difference of 2 (e.g., 3 and 5, 5 and 7, 11 and 13).

Step 9: Array

Code:

Explanation:

Part 1: Static Array Initialization

1. Array Declaration:
• DECLARE scores : ARRAY [1:5] OF INTEGER: Declares an array named scores with indices from 1 to 5, each element being an integer.

2. Assigning Values:
• scores[1] <-- 78
• scores[2] <-- 91
• scores[3] <-- 27
• scores[4] <-- 63
• scores[5] <-- 42
• Assigns specific integer values to each element of the scores array.

3. FOR Loop to Output Array Elements:
• FOR n <-- 1 TO LENGTH(scores): Loops from 1 to the length of scores (which is 5).
• OUTPUT scores[n]: Outputs each element in the array.
• NEXT n: Moves to the next index.

• Initializes an array with predefined scores and outputs each score:

Part 2: Dynamic Array with Random Values

1. Array Declaration:
• DECLARE scores : ARRAY [1:18] OF INTEGER: Declares an array named scores with indices from 1 to 18, each element being an integer.

2. FOR Loop to Assign Random Values:
• FOR i <-- 1 TO LENGTH(scores): Loops from 1 to 18.
• scores[i] <-- INT(RAND(100)): Assigns a random integer between 0 and 99 to each element in the array.
• NEXT i: Moves to the next index.

3. FOR Loop to Output Array Elements:
• FOR n <-- 1 TO LENGTH(scores): Loops from 1 to 18.
• OUTPUT scores[n]: Outputs each randomly assigned score.
• NEXT n: Moves to the next index.

• Creates an array of 18 integers, assigns each element a random number between 0 and 99, and then outputs all the scores.

Step 10: 2D Array

Code:

Explanation:

1. Initial Output:
• OUTPUT "三阶幻方": Outputs the string "三阶幻方", which is Chinese for "3x3 Magic Square".

2. 2D Array Declaration:
• DECLARE numbers : ARRAY[1:3, 1:3] OF STRING: Declares a two-dimensional array named numbers with rows and columns both ranging from 1 to 3. Each element is a STRING.

3. Array Initialization:
• numbers <-- [ ["8", "1", "6"], ["3", "5", "7"], ["4", "9", "2"] ]: Initializes the numbers array with the values of a classic 3x3 magic square. In a magic square, the sums of numbers in each row, column, and both main diagonals are equal (here, each sum is 15).

4. FOR Loop to Output the Magic Square:
• FOR n <-- 1 TO LENGTH(numbers): Loops through each row of the numbers array. Assuming LENGTH(numbers) returns the number of rows (3).
• OUTPUT numbers[n, 1] & " " & numbers[n, 2] & " " & numbers[n, 3]: Concatenates and outputs the three elements of each row separated by spaces.
• NEXT n: Moves to the next row.

• Prints out a 3x3 magic square. The output will look like:

Step 11: Nested Loops with Conditions

Code:

Explanation:

Part 1: Creating a 23x23 Grid with Specific Conditions

1. Variable Declaration and Initialization:
• DECLARE MyString : STRING: Declares a string variable MyString.
• MyString ← "": Initializes MyString as an empty string.

2. Nested FOR Loops:
• FOR a <-- 1 TO 23: Outer loop iterates a from 1 to 23.
• FOR b <-- 1 TO 23: Inner loop iterates b from 1 to 23.
• IF Conditions:
• (a = b AND a<>11 AND a<>10 AND a<>1): Checks if the current position is on the main diagonal (a = b) but not at positions 1, 10, or 11.
• (a + b = 24 AND a<>11 AND a<>10 AND a<>1): Checks if the current position is on the opposite diagonal (a + b = 24) but not at positions 1, 10, or 11.
• a = 12 OR b = 12: Checks if the current row or column is 12.
• THEN MyString ← MyString & "❤️": If any of the above conditions are true, appends a heart emoji to MyString.
• ELSE MyString ← MyString & "🟢": Otherwise, appends a green circle emoji.
• NEXT b: Ends the inner loop.
• MyString ← MyString & "\\n": Adds a newline character after completing each row.
• NEXT a: Ends the outer loop.

3. Output Statement:
• OUTPUT MyString: Displays the constructed string representing the grid.

• Constructs and outputs a 23x23 grid where:
• Cells on the main diagonal and the opposite diagonal (excluding specific positions) are marked with heart emojis.
• The entire 12th row and column are also marked with heart emojis.
• All other cells are marked with green circles.

• The result is a pattern of hearts and green circles forming specific shapes within the grid.

Part 2: Creating a 7x7 Grid with Diagonals

1. Initial Output:
• OUTPUT "shapes","\\n","\\n": Outputs the string "shapes" followed by two newline characters.

2. 2D Array Declaration:
• DECLARE numbers : ARRAY[1:7, 1:7] OF STRING: Declares a two-dimensional array numbers with rows and columns from 1 to 7.

3. Nested FOR Loops to Assign Emojis:
• FOR a <-- 1 TO 7: Outer loop for rows.
• FOR b <-- 1 TO 7: Inner loop for columns.
• IF a = b OR a + b = 8 THEN: Checks if the cell is on the main diagonal (a = b) or the opposite diagonal (a + b = 8).
• numbers[a, b] <-- "❤️": Assigns a heart emoji.
• ELSE: Otherwise,
• numbers[a, b] <-- "🟢": Assigns a green circle emoji.
• NEXT b: Ends the inner loop.
• NEXT a: Ends the outer loop.

4. FOR Loop to Output the 7x7 Grid:
• FOR n <-- 1 TO LENGTH(numbers): Iterates through each row.
• OUTPUT numbers[n, 1] & " " & numbers[n, 2] & " " & numbers[n, 3] & " " & numbers[n, 4] & " " & numbers[n, 5] & " " & numbers[n, 6] & " " & numbers[n, 7]: Concatenates and outputs all seven elements of the current row separated by spaces.
• NEXT n: Moves to the next row.

• Creates and displays a 7x7 grid where:
• Cells on the main diagonal (a = b) and the opposite diagonal (a + b = 8) are marked with heart emojis.
• All other cells are marked with green circles.

Step 12: Files

Code:

Explanation:

1. Variable Declaration:
• DECLARE file : STRING: Declares a string variable file.

2. FOR Loop:
• FOR n <-- 1 TO 6: Initiates a loop that runs six times with n from 1 to 6.

3. File Operations Inside the Loop:
• file <-- n & "a" & ".txt":
• Concatenates the current value of n with "a" and ".txt" to form a filename. For example, when n = 1, file becomes "1a.txt".
• OPENFILE file FOR WRITE: Opens the file named file in write mode. If the file doesn't exist, it is created.
• WRITEFILE file, RANDOM() * 1000:
• Generates a random floating-point number between 0 and 1 with RAND().
• Multiplies it by 1,000 to scale it up.
• Writes this number to the file.
• CLOSEFILE file: Closes the file after writing.

4. Loop Progression:
• NEXT n: Moves to the next iteration, incrementing n by 1.

• Creates six text files named 1a.txt, 2a.txt, 3a.txt, 4a.txt, 5a.txt, and 6a.txt.

• Each file is written with a random number between 0 and 1,000.

• Ensures that each file is properly closed after writing to prevent data corruption.

• File 1a.txt: Contains a random number like 345.67.

• File 2a.txt: Contains a random number like 123.45.

• ...

• File 6a.txt: Contains a random number like 987.65.

• The actual random numbers will vary each time the code is executed.

• This code demonstrates basic file I/O operations: creating, writing to, and closing files within a loop.

STEP 1-12 Summary

1. Variables: Declaration, initialization, and output.

2. Loops: FOR loops with and without step values, and WHILE loops.

3. Procedures and Functions: Creating reusable code blocks that perform specific tasks.

4. Conditional Statements: Using IF, ELSE, and logical operators to control program flow.

5. Arrays: Handling both one-dimensional and two-dimensional arrays.

6. Nested Loops and Conditions: Creating complex patterns and performing advanced computations.

7. File Operations: Automating file creation and data writing.

STEP 13 Symbols and Keywords

STEP 14 Past Paper Questions 001

9618/23/M/J/23 Q4:

1. take two parameters:

• a count as an integer

• a character

1. generate a string of length equal to the count, made up of the character

2. return the string generated, or return "ERROR" if the count is less than 1.

Solution:

STEP 15 Past Paper Questions 002

Step 16 Constructor

Step 17 Inheritance & Polymorphism

STEP 18 Recursive

STEP 19 More Past paper Questions

Q1: