Primitive data types(atomic data types) are those variables that can be defined simply by commands built into the programming language.

• Integer - whole number
• REAL - a number with a decimal point
• TRUE or FALSE - Conditions
• BOOLEAN - logical values
• CHAR - single character

Further data types

string - store serveral characters

The string data type is known as a structured type because it is essentially a sequence of characters.

Pseudocode data types

Sometimes variables of different data types are a logical group, such as data about a person (name, date of birth, height, number of siblings, whether they are a full-time student).

Name is a STRING; date of birth is a DATE; height is a REAL; number of siblings is an INTEGER; whether they are a full-time student is a BOOLEAN.

We can declare a record type to suit our purposes. The record type is known as a user-defined type, because the programmer can decide which variables (fields) to include as a record.

Pseudocode

// declare a record type

TYPE <TypeIdentifier> 
    DECLARE <field identifier> : <data type> 
    .
    .
ENDTYPE

// declare a variable of this recode type 

DECLARE <variable identifier> : <record type>

// access an individual filed using the dot notation

<variable identifier>.<field identifier>

// 1D array declaration
DECLARE <arrayIdentifier> : ARRAY[<lowerBound>:<upperBound>] OF <dataType>

// pseudocode example
DECLARE List1 : ARRAY[1:3] OF STRING // 3 elements in this list 
DECLARE List2 : ARRAY[0:5] OF INTEGER // 6 elements in this list 
DECLARE List3 : ARRAY[1:100] OF INTEGER // 100 elements in this list 
DECLARE List4 : ARRAY[0:25] OF CHAR // 26 elements in this list

// accessing 1D array
<arrayIdentifier>[x]

// pseudocode example
NList[25] ← 0
AList[3] ← 'D'

Example 1 - Working with one-dimensional array

Requirement

Take seven numbers as input and store them for later use.

Pseudocode

FOR Index ← 0 TO 6 
    INPUT MyList[Index] 
NEXT Index

Requirement

Take a number as input. Search for this number in an existing 1D array of seven numbers

Identifier

Pseudocode

MaxIndex ← 6 
INPUT SearchValue 
Found ← FALSE 
Index ← –1 
REPEAT 
    Index ← Index + 1
    IF MyList[Index] = SearchValue
        THEN 
            Found ← TRUE 
    ENDIF 
UNTIL FOUND = TRUE OR Index >= MaxIndex 
IF Found = TRUE 
    THEN 
        OUTPUT "Value found at location: " Index 
    ELSE 
        OUTPUT "Value not found" 
ENDIF

Identifier table

simplest way

1. Compare the first and second values. If the first value is larger than the second value, swap them.
2. Compare the second and third values. If the second value is larger than the third value, swap them.
3. Compare the third and fourth values. If the third value is larger than the fourth value, swap them.
4. Keep on comparing adjacent values, swapping them if necessary, until the last two values in the list have been processed.

Pseudocode

n ← MaxIndex – 1 
FOR i ← 0 TO MaxIndex – 1
    FOR j ← 0 TO n
        IF MyList[j] > MyList[j + 1] 
            THEN
                Temp ← MyList[j]
                MyList[j] ← MyList[j + 1]
                MyList[j + 1] ← Temp
        ENDIF 
    NEXT j 
    n ← n – 1 // this means the next time round the inner loop, we don't 
              // look at the values already in the correct positions. 
NEXT i

improved

We can use a variable NoMoreSwaps to store whether or not a swap has taken place during the current pass. We initialise the variable NoMoreSwaps to TRUE. When we swap a pair of values we set NoMoreSwaps to FALSE. At the end of the pass through the array we can check whether a swap has taken place.

identifier table

Pseudocode

n ← MaxIndex – 1 
REPEAT 
    NoMoreSwaps ← TRUE
    FOR j ← 0 TO n
        IF MyList[j] > MyList[j + 1]
        THEN
            Temp ← MyList[j]
            MyList[j] ← MyList[j + 1]
            MyList[j + 1] ← Temp
            NoMoreSwaps ← FALSE
        ENDIF
    NEXT j
    n ← n – 1
UNTIL NoMoreSwaps = TRUE

// declaration
DECLARE <identifier> : ARRAY[<lBound1>:<uBound1>, <lBound2>:<uBound2>] OF <dataType>
# example
Board : ARRAY[1:6,1:7] OF INTEGER

// Accessing 2D arrays
<arrayIdentifier>[x,y]
# example
Board[3,4] ← 0 // sets the element in row 3 and column 4 to zero

Example - Working with two-dimensional arrays and nested loops

// set each element of array to zero
FOR Row ← 0 TO MaxRowIndex 
    FOR Column ← 0 TO MaxColumnIndex 
        ThisTable[Row, Column] ← 0 
    NEXT Column 
NEXT Row

// output

FOR Row ← 0 TO MaxRowIndex 
    FOR Column ← 0 TO MaxColumnIndex 
        OUTPUT ThisTable[Row, Column] // stay on same line 
    NEXT Column 
    OUTPUT Newline // move to next line for next row 
NEXT Row

Data need to be stored permanently. One approach is to use a file.

A text file consists of a sequence of characters formatted into lines. Each line is terminated by an end-of-line marker. The text file is terminated by an end-of-file marker.

Text file pseudocode

// writing a text file
OPENFILE <filename> FOR WRITE   //open the file for writing
WRITEFILE <filename>, <stringValue>    //write a line of text to the file 
CLOSEFILE <filename> //close file

// reading from a text file 
OPENFILE <filename> FOR READ // open file for reading
READFILE <filename>, <stringVariable> // read a line of text from the file
CLOSEFILE <filename>  // close file

// Appending to a text file
OPENFILE <filename> FOR APPEND // open file for append 
WRITEFILE <filename>, <stringValue> // write a line of text to the file 
CLOSEFILE <filename> // close file

// The end-of-file(EOF) marker
OPENFILE "Test.txt" FOR READ 
WHILE NOT EOF("Test.txt") DO
    READFILE "Test.txt", TextString 
    OUTPUT TextString 
ENDWHILE 
CLOSEFILE "Test.txt"

When people form a queue, they join the queue at the end. People leave the queue from the front of the queue.

a circular queue after 11 items have joined and five items have left the queue.