Write pseudocode to process array data

10.2 Arrays – Writing Pseudocode to Process Array Data

1. Where Arrays Fit in the Cambridge AS & A‑Level Computer Science Syllabus

• Data Types & Structures (Syllabus 10): Arrays are the fundamental collection type used to store homogeneous data.
• Algorithm Design & Problem‑solving (Syllabus 9): Traversal, searching, sorting, insertion and deletion are core algorithmic techniques.
• Information Representation (Syllabus 1): Arrays often hold binary, hexadecimal or Unicode values; they model memory blocks.
• Hardware & CPU Fundamentals (Syllabus 3‑4): Array indexing mirrors address calculation in RAM; bit‑wise manipulation of array elements is a common low‑level operation.
• System Software (Syllabus 5): Compilers and interpreters translate array operations into machine code; operating systems manage the memory that stores arrays.
• Security, Ethics & Data Integrity (Syllabus 6‑7): Validation of indices and values prevents out‑of‑range errors and protects data privacy.
• Databases & Data Management (Syllabus 8): Simple record‑based files can be represented as arrays of structures.
• Software Development Life‑Cycle (Syllabus 12): Designing, testing and documenting array‑based algorithms follows the SDLC stages.
• Artificial Intelligence (Syllabus 18): Many AI‑related algorithms (e.g., linear regression, neural‑network weight vectors) start with array data.

2. Notation & Indexing

• Array bounds – Cambridge pseudocode requires explicit lower and upper bounds:

  DECLARE arr : ARRAY[lowerBound..upperBound] OF TYPE

• Default 1‑based indexing – The first element is at index 1 unless the question states otherwise.
• Guard against illegal indices (useful for safety checks):

  IF i < lowerBound OR i > upperBound THEN
      OUTPUT "Index out of range!"
      STOP
  END IF

3. Declaring & Initialising an Array

General declaration syntax:

DECLARE  : ARRAY[lowerBound..upperBound] OF 

Example – an integer array for 10 test scores:

DECLARE scores : ARRAY[1..10] OF INTEGER

All elements receive a default value (0 for numbers, “” for strings, FALSE for booleans). If a different start value is required, initialise explicitly (see the templates in §5).

4. Accessing & Updating Elements

• Read: value ← array[i]
• Write: array[i] ← value
• In‑place update example (add 5 to each element):

  FOR i ← lowerBound TO upperBound DO
      array[i] ← array[i] + 5
  END FOR

5. Core Array Operations – Pseudocode Templates

FOR i ← lowerBound TO upperBound DO
    array[i] ← v
END FOR

SET sum ← 0
FOR i ← lowerBound TO upperBound DO
    sum ← sum + array[i]
END FOR

SET max ← array[lowerBound]
FOR i ← lowerBound+1 TO upperBound DO
    IF array[i] > max THEN
        SET max ← array[i]
    END IF
END FOR

SET found ← FALSE
FOR i ← lowerBound TO upperBound DO
    IF array[i] = x THEN
        SET found ← TRUE
        EXIT FOR
    END IF
END FOR

SET low ← lowerBound
SET high ← upperBound
SET found ← FALSE
WHILE low ≤ high AND NOT found DO
    SET mid ← (low + high) DIV 2
    IF array[mid] = x THEN
        SET found ← TRUE
    ELSEIF array[mid] < x THEN
        SET low ← mid + 1
    ELSE
        SET high ← mid - 1
    END IF
END WHILE

FOR pass ← lowerBound TO upperBound-1 DO
    FOR i ← lowerBound TO upperBound-pass DO
        IF array[i] > array[i+1] THEN
            SET temp ← array[i]
            SET array[i] ← array[i+1]
            SET array[i+1] ← temp
        END IF
    END FOR
END FOR

FOR i ← lowerBound TO upperBound-1 DO
    SET minIdx ← i
    FOR j ← i+1 TO upperBound DO
        IF array[j] < array[minIdx] THEN
            SET minIdx ← j
        END IF
    END FOR
    IF minIdx ≠ i THEN
        SET temp ← array[i]
        SET array[i] ← array[minIdx]
        SET array[minIdx] ← temp
    END IF
END FOR

FOR i ← lowerBound+1 TO upperBound DO
    SET key ← array[i]
    SET j ← i-1
    WHILE j ≥ lowerBound AND array[j] > key DO
        SET array[j+1] ← array[j]
        SET j ← j-1
    END WHILE
    SET array[j+1] ← key
END FOR

FOR i ← upperBound DOWNTO p+1 DO
    array[i] ← array[i-1]
END FOR
SET array[p] ← v

FOR i ← p TO upperBound-1 DO
    array[i] ← array[i+1]
END FOR
/* Optional: clear the now‑unused last element */
SET array[upperBound] ← 0

6. Detailed Example – Calculating the Average Grade

Given an array marks[1..n], compute the average and display it to two decimal places.

DECLARE n, i : INTEGER
DECLARE marks : ARRAY[1..100] OF INTEGER
DECLARE total : INTEGER
DECLARE average : REAL

READ n
/* 1️⃣ Input the marks */
FOR i ← 1 TO n DO
    READ marks[i]
END FOR

/* 2️⃣ Compute the total */
SET total ← 0
FOR i ← 1 TO n DO
    total ← total + marks[i]
END FOR

/* 3️⃣ Calculate and output the average */
SET average ← total / n
OUTPUT "Average = ", average TO 2DP

7. Linking Arrays to Other Syllabus Areas

7.1 Information Representation (Syllabus 1)

• Binary & Hexadecimal storage: An 8‑bit byte can be modelled as bits[1..8]. Converting a decimal number to binary is a classic array exercise.

  DECLARE n : INTEGER
  DECLARE bits : ARRAY[1..8] OF INTEGER
  SET n ← 173          /* decimal */
  FOR i ← 8 DOWNTO 1 DO
      SET bits[i] ← n MOD 2
      SET n ← n DIV 2
  END FOR

• Unicode / ASCII strings are arrays of characters; each character can be accessed via its index.
• BCD (Binary‑Coded Decimal) can be stored as an array of 4‑bit nibbles.

7.2 Multimedia (Syllabus 1.2‑1.3)

• Images are two‑dimensional arrays of pixel values, e.g. image[1..height][1..width]. A simple greyscale inversion:

  FOR r ← 1 TO height DO
      FOR c ← 1 TO width DO
          SET image[r][c] ← 255 - image[r][c]
      END FOR
  END FOR

• Sound samples can be stored in a one‑dimensional array of amplitudes.

7.3 Communication & Networks (Syllabus 2)

• Transmitting an array over a network involves serialising each element. Pseudocode sketch:

  FOR i ← lowerBound TO upperBound DO
      SEND array[i] TO destination
  END FOR

• Receiving data into an array follows the same pattern with RECEIVE.

7.4 Hardware & CPU Fundamentals (Syllabus 3‑4)

• Array indexing mirrors address calculation: address = baseAddress + (i‑lowerBound) × elementSize.
• Bit‑wise operations on integer array elements (AND, OR, XOR, NOT, SHIFT) are essential for low‑level programming and are directly supported by pseudocode:

  SET array[i] ← array[i] AND 0x0F   /* keep lower 4 bits */

7.5 System Software (Syllabus 5)

• Compilers translate the high‑level array operations shown above into machine instructions that manipulate RAM.
• Operating systems allocate contiguous memory blocks for static arrays and manage dynamic resizing (not required in Cambridge exams but useful context).

7.6 Security, Privacy & Data Integrity (Syllabus 6‑7)

• Always validate indices before accessing an array (see the guard in §2).
• When reading user‑supplied data, check that values fall within expected ranges to avoid overflow or injection attacks.
• For sensitive data (e.g., passwords) consider clearing the array after use:

  FOR i ← lowerBound TO upperBound DO
      array[i] ← 0
  END FOR

7.7 Databases & Data Management (Syllabus 8)

• A simple table can be represented as an array of records:

  DECLARE student : RECORD
      id   : INTEGER
      name : STRING
      mark : INTEGER
  END RECORD
  DECLARE students : ARRAY[1..30] OF student

• Searching for a student by ID then becomes a linear search on the students array.

7.8 Software Development Life‑Cycle (Syllabus 12)

1. Analyse the problem – identify required array size and operations.
2. Design – choose appropriate templates (traversal, sort, search).
3. Implement – write clear, indented pseudocode following the Cambridge conventions.
4. Test – run through edge cases (empty array, single element, maximum capacity, duplicate values).
5. Maintain – comment any assumptions (e.g., “array is sorted”) and update logical size variables after insert/delete.

7.9 Artificial Intelligence (Syllabus 18)

• Many introductory AI algorithms start with numeric vectors stored in arrays – e.g., a weight vector for a perceptron:

  DECLARE weights : ARRAY[1..n] OF REAL
  /* initialise */
  FOR i ← 1 TO n DO
      SET weights[i] ← 0.0
  END FOR

• Training involves traversing the array and updating each element, a pattern identical to the “in‑place update” template.

8. Common Pitfalls & How to Avoid Them

• Index out of range: Verify loop limits match declared bounds; use the guard from §2 for dynamic indices.
• Mixing 0‑based and 1‑based indexing: Cambridge pseudocode defaults to 1‑based – only deviate when the question explicitly states a different lower bound.
• Forgetting to adjust the logical size after insertion or deletion (e.g., increment or decrement n).
• Not resetting accumulator variables (e.g., sum, total) before re‑using them in a new pass.
• Applying binary search to an unsorted array: Sort first or revert to linear search.
• Ignoring data‑type limits: When using bit‑wise operations, remember the size of the underlying type (8‑bit, 16‑bit, etc.).

9. Summary Checklist

1. Declare the array with correct lowerBound, upperBound and data type.
2. Confirm the problem’s logical size (e.g., n) fits within the declared bounds.
3. Initialise the array if a non‑default start value is required.
4. Use a loop that respects the bounds; add an explicit guard when indices are computed.
5. Select the appropriate algorithm (initialise, traverse, search, sort, insert, delete) and follow the matching template.
6. Update the logical size after any insertion or deletion.
7. Test edge cases: empty array, single element, full capacity, duplicate values, already sorted data.
8. Document assumptions (sorted?, 1‑based?, maximum size?) and any security checks performed.

10. Practice Questions

1. Write pseudocode to reverse the elements of an integer array a[1..n] in place.
2. Given an array temps[1..30] containing daily temperatures, write pseudocode to find the number of days with temperature above the monthly average.
3. Explain why a binary search requires the array to be sorted and give the pseudocode for binary search on a 1‑based indexed array.
4. Implement selection sort for an array scores[1..m] and output the sorted list.
5. Write pseudocode to delete the element at position p from an array data[1..k] and adjust the logical size accordingly.
6. Convert the decimal number 198 to an 8‑bit binary array bits[1..8] (most‑significant bit first).
7. Design a simple image‑inversion routine for a greyscale picture stored in image[1..h][1..w].
8. Show how you would safely transmit an integer array values[1..n] over a network, including a basic error‑check for missing elements.