pseuocode guide

Question 1

What are the basic data types in pseudocode and their descriptions?

Answer 1

INTEGER: A whole number.
REAL: A number capable of containing a fractional part.
CHAR: A single character.
STRING: A sequence of zero or more characters.
BOOLEAN: The logical values TRUE and FALSE.
DATE: A valid calendar date.

Question 2

How are literals of the basic data types written in pseudocode?

Answer 2

Integer: Written in the denary system, e.g., 5, -3.
Real: Written with at least one digit on either side of the decimal point, e.g., 4.7, 0.3, -4.0.
Char: A single character delimited by single quotes, e.g., 'x', 'C'.
String: Delimited by double quotes, e.g., "This is a string", "" (empty string).
Boolean: TRUE, FALSE.
Date: Typically written as dd/mm/yyyy and explicitly declared as DATE with an explanation of the format.

Question 3

What rules apply to naming identifiers in pseudocode?

Answer 3

• Identifiers must start with a letter (A–Z or a–z).
• Can include letters, digits (0–9), and the underscore (_).
• Must not contain accented letters.
• Should not use keywords as identifiers.
• Case-insensitive (e.g., Counter and counter are treated as the same).
• Use descriptive names or conventional single letters (e.g., i, j for indices).

Question 4

How should variables be declared in pseudocode?

Answer 4

DECLARE <identifier> : <data type>

Example:

DECLARE Counter : INTEGER  
DECLARE TotalToPay : REAL  
DECLARE GameOver : BOOLEAN  

Question 5

Why is it good practice to explicitly declare variables in pseudocode?

Answer 5

• Ensures clarity about the type and purpose of the variable.
• Helps avoid using undeclared or improperly initialised variables.

Question 6

How are Boolean literals written in pseudocode?

Answer 6

As TRUE and FALSE

Question 7

How should date literals be represented in pseudocode?

Answer 7

• Format: dd/mm/yyyy
• Explicitly state the data type as DATE
• Explain the format to avoid confusion due to regional differences

Question 8

Why is it good practice to use constants in pseudocode?

Answer 8

• Constants make pseudocode more readable as identifiers are often more meaningful than literals.
• They simplify updates if the constant’s value changes.

Question 9

How are constants declared in pseudocode?

Answer 9

CONSTANT <identifier> = <value>

Example:

CONSTANT HourlyRate = 6.50  
CONSTANT DefaultText = "N/A"

Only literals can be used as the value of a constant in pseudocode. Variables, other constants, or expressions must not be used.

Question 10

What is the assignment operator in pseudocode?

Answer 10

←

Question 11

How are assignments made in pseudocode?

Answer 11

<identifier> ← <value>

Examples:

Counter ← 0
Counter ← Counter + 1
TotalToPay ← NumberOfHours * HourlyRate

Question 12

How are one-dimensional arrays declared in pseudocode?

Answer 12

DECLARE <identifier>:ARRAY[<lower>:<upper>] OF <data type>

Example:

DECLARE StudentNames : ARRAY[1:30] OF STRING

Question 13

How are two-dimensional arrays declared in pseudocode?

Answer 13

DECLARE <identifier>:ARRAY[<lower1>:<upper1>,<lower2>:<upper2>] OF <data type>

Example:

DECLARE NoughtsAndCrosses : ARRAY[1:3,1:3] OF CHAR

Question 14

What is the lower bound of an array, and why should it be explicitly stated?

Answer 14

• The lower bound is the index of the first element in an array.
• It defaults to either 0 or 1 depending on the system, so explicitly stating it ensures clarity. A lower bound of 1 is generally used on pseudocode.

Question 15

What can be used as array index values in pseudocode?

Answer 15

Array index values can be:
- Literal values (e.g., 1, 2)
- Expressions that evaluate to valid integers (e.g., n+1)

Question 16

How do you assign a value to an individual element in a one-dimensional array?

Answer 16

ArrayName[Index] ← <value>

Example:

StudentNames[1] ← "Giorno"

Question 17

How do you assign a value to an individual element in a two-dimensional array?

Answer 17

ArrayName[Index1, Index2] ← <value>

Example:

NoughtsAndCrosses[2,3] ← ꞌXꞌ

Question 18

Can arrays be assigned to each other in pseudocode?

Answer 18

Arrays can be assigned to each other if:
- They are of the same size.
- They have the same data type.

SavedGame ← NoughtsAndCrosses

Question 19

Why should a group of array elements not be accessed individually in a statement?

Answer 19

• It is not recommended for clarity and efficiency.
  DO NOT:

StudentNames[1 TO 30] ← ""
// correct but no marks

• Instead, use a loop to iterate over and process the elements individually.
  DO:

FOR Index ← 1 TO 30
    StudentNames[Index] ← ""
NEXT Index

Question 20

How can you assign a value to a group of array elements?

Answer 20

Use a loop structure:

FOR Index ← <lower> TO <upper>
    ArrayName[Index] ← <value>
NEXT Index

Example:

FOR Index ← 1 TO 30
    StudentNames[Index] ← ""
NEXT Index

Question 21

What is a user-defined non-composite data type with a list of possible values called?

Answer 21

An enumerated data type

Question 22

How do you declare an enumerated data type in pseudocode?

Answer 22

TYPE <identifier> = (value1, value2, value3, ...)

Example:

TYPE Season = (Spring, Summer, Autumn, Winter)

Question 23

What is a user-defined non-composite data type that references a memory location called?

Answer 23

A pointer

Question 24

How do you declare a pointer type in pseudocode?

Answer 24

TYPE <identifier> = ^<data type>

Example:

TYPE TIntPointer = ^INTEGER
TYPE TCharPointer = ^CHAR

Question 25

How do you declare a pointer variable?

Answer 25

Does not require the caret (^) symbol. ``` DECLARE : ``` Example: ``` DECLARE MyPointer : TIntPointer ```

Question 26

What is a composite data type in pseudocode?

Answer 26

A collection of data that can consist of different data types, grouped under one identifier.

Question 27

How do you declare a composite data type in pseudocode?

Answer 27

``` TYPE DECLARE : DECLARE : ... ENDTYPE ``` Example: ``` TYPE Student DECLARE LastName : STRING DECLARE FirstName : STRING DECLARE DateOfBirth : DATE DECLARE YearGroup : INTEGER DECLARE FormGroup : CHAR ENDTYPE ```

Question 28

How do you use a composite data type to declare a variable?

Answer 28

``` DECLARE : ``` Example: ``` DECLARE Pupil : Student ```

Question 29

How do you declare variables using user-defined data types?

Answer 29

``` DECLARE : ``` Examples: ``` DECLARE Pupil1 : Student DECLARE ThisSeason : Season DECLARE MyPointer : TIntPointer ```

Question 30

How do you access individual items in a user-defined composite data type?

Answer 30

Using dot notation. Example: ``` Pupil1.LastName ← "Johnson" Pupil1.YearGroup ← 6 ```

Question 31

Can variables of user-defined data types be assigned to each other?

Answer 31

Yes, if they share the same data type. Example: ``` Pupil2 ← Pupil1 ```

Question 32

How are arrays of user-defined data types declared and used?

Answer 32

Example: ``` DECLARE Form : ARRAY[1:30] OF Student Form[Index].YearGroup ← Form[Index].YearGroup + 1 ```

Question 33

How do you input values in pseudocode?

Answer 33

``` INPUT ``` Example: ``` INPUT Answer ```

Question 34

How do you output values in pseudocode?

Answer 34

``` OUTPUT ``` Example: ``` OUTPUT Score OUTPUT "You have ", Lives, " lives left" ```

Question 35

What are the standard arithmetic operators in pseudocode and their functions?

Answer 35

`+` Addition `-` Subtraction `*` Multiplication `/` Division (result is REAL) `DIV` Integer division (quotient) `MOD` Modulus (remainder)

Question 36

What is the precedence of arithmetic operators?

Answer 36

Multiplication and division have higher precedence than addition and subtraction. The order of operations be made explicit by using parentheses: ``` Result ← (A + B) * C ```

Question 37

What are the relational operators used in pseudocode?

Answer 37

`>` Greater than `<` Less than `>=` Greater than or equal to `<=` Less than or equal to `=` Equal to `<>` Not equal to

Question 38

What data type is the result of a relational operation?

Answer 38

BOOLEAN

Question 39

How can the order of operations in complex relational expressions be clarified?

Answer 39

By using parentheses

Question 40

What are the logic operators in pseudocode?

Answer 40

AND OR NOT