Flashcards for Pseudocode questions

Development Process Programming Fundamentals (Year 11)

Writing the code that implements the design in the chosen language, following the algorithms and good coding practice (comments, naming, modular subroutines).

Example: Development turns the design into working code.

Algorithm Term Programming Fundamentals (Year 11)

A finite, ordered set of clear steps that solves a problem or completes a task, with defined inputs and outputs.

Example: An algorithm can be shown as pseudocode or a flowchart.

Sequence Term Programming Fundamentals (Year 11)

A control structure where statements run one after another in the order written.

Example: Every program uses sequence; selection and iteration change the order.

Selection Term Programming Fundamentals (Year 11)

A control structure that chooses which path to run depending on a condition: binary selection (IF ... ELSE), multi-way selection (CASEWHERE) or nested IF.

Example: 'Use IF/ELSE selection to output Pass when mark >= 50.'

Iteration (repetition) Term Programming Fundamentals (Year 11)

A control structure that repeats statements while or until a condition: pre-test loop (WHILE ... ENDWHILE), post-test loop (REPEAT ... UNTIL) or counted loop (FOR ... NEXT).

Example: 'FOR each item in the array: total = total + item.'

Refinement Term Programming Fundamentals (Year 11)

Adding successively more detail: a subroutine is expanded into its own algorithm or structure chart, named the same as the subroutine.

Example: 'Show the refinement of the Validate subroutine in a separate chart.'

Pseudocode Term Programming Fundamentals (Year 11)

Structured, language-independent English-like code: keywords in capitals (IF, ELSE, WHILE, ENDWHILE, FOR, NEXT, SET, GET, DISPLAY), paired structures and consistent indentation.

Example: Always write a mainline plus subroutines, use indentation and close every structure (ENDIF, ENDWHILE).

Subroutine (module, subprogram, procedure) Term Programming Fundamentals (Year 11)

A named block of statements that performs one specific task and can be called many times; the terms subroutine, module, subprogram and procedure are used interchangeably in the course.

Example: 'One logical task per subroutine makes code reusable and easier to maintain.'

Function v procedure Term Programming Fundamentals (Year 11)

A function returns a value to the caller (RETURN); a procedure carries out a task and does not return a value.

Example: 'def calc_total(a, b): return a + b' is a function.

Parameter and argument Term Programming Fundamentals (Year 11)

A parameter is a variable in the subroutine's definition that receives data; an argument is the actual value passed when the subroutine is called.

Example: 'def greet(name)' has parameter name; 'greet("Sam")' passes argument "Sam".

Mainline Term Programming Fundamentals (Year 11)

The main algorithm that controls the program by calling subroutines in order. Good mainlines are clear and uncluttered.

Example: Put calls to your subroutines in the mainline, and call functions after they are defined (2025 Q19 marker note).

Inputs, outputs and purpose of an algorithm Term Programming Fundamentals (Year 11)

When analysing an algorithm, identify the data it takes in (inputs), the results it produces (outputs), what it is designed to do (purpose) and how it connects to other subroutines.

Example: 'Inputs: array of marks. Output: the average. Purpose: calculate the class mean.'

Check this one: Not found word-for-word in the supplied syllabus, specifications, marking guidelines or notes; the definition is standard computing knowledge, so check it against your class notes.

Linear search Term Programming Fundamentals (Year 11)

A search that checks each item in order until the target is found or the list ends. Works on unsorted data; slow for large lists.

Example: 'FOR i = 0 TO length-1: IF list[i] == target THEN found.'

Check this one: Not named in the syllabus; it appears in past questions and the school notes.

Binary search Term Programming Fundamentals (Year 11)

A search on a SORTED list that checks the middle item and discards half the list each time (a divide and conquer method).

Example: 'Binary search needs sorted data; each step halves the search space.'

Check this one: Not named in the syllabus; it appears in past SDD questions.

Array Term Programming Fundamentals (Year 11)

A data structure holding a fixed number of items of the same type, accessed by index; can be single or multi-dimensional (rows and columns).

Example: 'marks[0]' is the first item.

Clear and uncluttered mainline Term The Object-Oriented Paradigm (Year 11)

A mainline that only calls well-named subroutines or methods in order, so the overall flow is easy to follow.

Example: Keep the mainline to a few calls; put detail in subroutines.

One logical task per subroutine Term The Object-Oriented Paradigm (Year 11)

Each subroutine does a single clear job, which makes it reusable, testable and easier to fix.

Example: 'calculateTotal() only calculates; displayTotal() only displays.'

Closed-loop control Term Programming Mechatronics (Year 11)

A control system where sensors feed the result back and the algorithm adjusts the output to reach a target (thermostat, cruise control).

Example: 'Closed: read the sensor, compare with the target, adjust the motor.'

Control algorithm pattern (line follower) Code pattern Programming Mechatronics (Year 11)

A closed-loop loop: WHILE the robot is running, read the sensor, IF the sensor sees dark THEN turn one way ELSE turn the other, ENDIF, ENDWHILE.

Example: 'WHILE on: read light; IF dark THEN turn left ELSE turn right.'

Check this one: Not found word-for-word in the supplied syllabus, specifications, marking guidelines or notes; the definition is standard computing knowledge, so check it against your class notes.

Mainline and subroutines (algorithms) Diagram Diagrams and Modelling Tools (Years 11 and 12)

Start complex algorithms with a clear, uncluttered mainline that calls subroutines; the details of each subroutine are in separate algorithms.

Example: 'BEGIN Main: GetData, Process, Display END.'

Pseudocode keywords Code pattern Code Patterns: Pseudocode, Python, SQL, CSS (Years 11 and 12)

Keywords are in capitals; structural elements come in pairs (BEGIN/END, IF/ENDIF, WHILE/ENDWHILE); indent to show control structures.

Example: 'IF mark >= 50 THEN ... ENDIF'

Sequence Code pattern Code Patterns: Pseudocode, Python, SQL, CSS (Years 11 and 12)

Steps executed one after another in the order written.

Example: 'GET a; GET b; total = a + b'

Binary selection (IF THEN ELSE) Code pattern Code Patterns: Pseudocode, Python, SQL, CSS (Years 11 and 12)

IF condition THEN process ELSE other process ENDIF: one of two paths is taken.

Example: 'IF age >= 18 THEN DISPLAY "Adult" ELSE DISPLAY "Minor" ENDIF'

Multi-way selection (CASEWHERE) Code pattern Code Patterns: Pseudocode, Python, SQL, CSS (Years 11 and 12)

CASEWHERE expression evaluates to choice a: ... OTHERWISE: default END CASE; only one process runs.

Example: 'CASEWHERE grade evaluates to "A": ... OTHERWISE: ...'

Nested IF Code pattern Code Patterns: Pseudocode, Python, SQL, CSS (Years 11 and 12)

An IF inside the ELSE of another IF to test several conditions where only one process runs.

Example: 'IF a THEN ... ELSE IF b THEN ... ELSE ... ENDIF ENDIF'

WHILE loop (pre-test) Code pattern Code Patterns: Pseudocode, Python, SQL, CSS (Years 11 and 12)

WHILE condition is true ... ENDWHILE: the condition is tested before each loop, so the body may never run.

Example: 'WHILE count < 5 ... ENDWHILE'

REPEAT UNTIL loop (post-test) Code pattern Code Patterns: Pseudocode, Python, SQL, CSS (Years 11 and 12)

REPEAT ... UNTIL condition is true: the body runs at least once, then the condition is tested.

Example: 'REPEAT GET guess UNTIL guess = answer'

FOR / NEXT loop (counted) Code pattern Code Patterns: Pseudocode, Python, SQL, CSS (Years 11 and 12)

FOR variable = start TO finish STEP increment ... NEXT variable; used when the number of repeats is known.

Example: 'FOR i = 1 TO 5 ... NEXT i'

Check this one: Not found word-for-word in the supplied syllabus, specifications, marking guidelines or notes; the definition is standard computing knowledge, so check it against your class notes.

Subroutine and function (pseudocode) Code pattern Code Patterns: Pseudocode, Python, SQL, CSS (Years 11 and 12)

BEGIN name (parameters) ... END name. A function returns a single value with RETURN.

Example: 'BEGIN Add (x, y) total = x + y RETURN total END Add'

Array sum pattern Code pattern Code Patterns: Pseudocode, Python, SQL, CSS (Years 11 and 12)

Set total to 0, loop through every item adding it to the total, then display the total (initialise, loop, accumulate, output).

Example: 'total = 0; FOR each item: total = total + item'

Check this one: A coding pattern from the exam solution style, not a syllabus term.

Linear search pattern Code pattern Code Patterns: Pseudocode, Python, SQL, CSS (Years 11 and 12)

Check each item in order until found or the end is reached; set a Found flag, loop through and stop on a match.

Example: 'found = False; for i in list: if i == target: found = True'

Construct Command word Command Words and Question-type Skills

Make; build; put together items or arguments.

Example: 'Construct a SQL query.' Answer: build the diagram, query or code with every required feature.

Pseudocode questions Process Command Words and Question-type Skills

Write HSC-style pseudocode: capital keywords, paired END words, indentation; initialise variables; output the required result.

Example: 2025 Q17 array sum.