QCE Digital Solutions Unit 1 — Algorithms and Programming Techniques Hangman

The 87 key terms

1algorithm

A set of clear steps, in order, that solves a problem or completes a task, like a recipe or morning routine. Each step must be precise so a person or computer can follow it.

2IPO chart

A three-column table listing a solution's inputs (data entered), the processes applied to that data, and the outputs it produces, such as a total or report.

3five features of programming

Every program is built from five features: variables, control structures, data structures, syntax, and libraries and classes.

4sequence, branching, iteration

The three building blocks of algorithms: steps in order, decisions (IF) and repeats (loops). Traffic lights, self-serve checkouts, automatic doors and alarm apps all use them.

5condition

A question about the situation that can only be answered true or false (yes or no), like 'Is it raining?' or 'Is the score above 10?'. It helps an algorithm decide what to do.

6flowchart

A diagram that uses an oval for start and end, a rectangle for a step and a diamond for a yes or no question, all joined by arrows that show the order.

7decision diamond

A diamond shape in a flowchart that asks a yes or no question. One arrow is labelled Yes and one is labelled No, and each arrow leads to different steps.

8loop arrow

An arrow that goes back to an earlier shape so steps repeat. The loop stops when the decision's exit arrow is followed, such as when the answer is Yes.

9step = shape

Each numbered step becomes one flowchart shape. An IF becomes a diamond, and a REPEAT becomes an arrow going back to an earlier shape. Both versions should do the same thing.

10flowchart to steps

Changing a flowchart into written steps: a diamond becomes IF or a loop condition, a back arrow becomes REPEAT, then check both versions do the same thing.

11end if

A closing keyword in VCAA pseudocode that ends an if block; every nested construct uses end followed by its matching keyword: end if, end while, end for

12Algorithm:

The required header keyword that names a VCAA maths pseudocode algorithm. Written as Algorithm: followed by a descriptive name, it must appear as the first line before input or processing

13input

A VCAA pseudocode keyword that accepts a value from the user and stores it in a named variable. Example: input age stores the user's entered value in the variable age

14print

A VCAA pseudocode keyword that outputs a value, variable or expression as a result. Example: print area displays the current value stored in the variable area

16MOD

The pseudocode operator that returns the remainder after integer division. Example: 10 MOD 3 gives 1 because 10 divided by 3 is 3 remainder 1

18AND

A VCAA pseudocode boolean operator that combines two conditions. The overall result is true only when BOTH conditions are true. Example: x > 0 AND x < 10

19IPO to pseudocode

Turn each IPO input into an INPUT statement, each process into assignments or IF selection, and each output into a PRINT statement, in that order.

21IF-THEN-ELSE

A selection structure that runs one set of instructions if a condition is true, and a different set if it is false

22ELSE IF

A keyword that adds another condition to check if the previous IF or ELSE IF condition was false

23nested if

An if block written inside another if block. The inner condition is only checked when the outer condition is true. Indent the inner block and give each if its own end if.

24FOR i FROM 1 TO n

A loop that repeats its instructions a fixed number of times, counting the variable i from 1 up to n

25WHILE condition DO

A loop that repeats its instructions for as long as the given condition remains true, checked before each repetition

26REPEAT ... UNTIL condition

A loop that repeats its instructions and checks the condition after each repetition, so the body always runs at least once

27count <- count + 1

A counter. It adds 1 to a variable each time a loop repeats. Set it to 0 before the loop. An accumulator works the same way: total <- total + x adds a value each time.

28define

A keyword that starts a function definition, naming the function and listing the parameters it accepts

29addNumbers(a: INTEGER, b: INTEGER): INTEGER

A function header specifying the function's name, its typed parameters, and the data type of its return value

30return

A keyword that sends a value back from a function to where it was called, ending the function's execution at that point

31addNumbers(3, 4)

Calling a function by writing its name followed by arguments in brackets, running its instructions and possibly producing a value

32program

A text file of Python instructions. You write it in the editor, and when you press Run, Python does each line in order from first to last and shows the output in the output panel.

35syntax error

An error that occurs when Python cannot understand your code due to a typo, missing quote, or wrong bracket; Python stops and shows a message with the line number

40sequence

A control structure where statements run one after another, top to bottom, so changing their order can change the result.

45GST_RATE = 0.1

A constant: a named value set once and never changed while the program runs. Written in UPPER_CASE by convention, it replaces magic numbers and is easy to update in one place.

51IndentationError

Python errors when a block's lines are not indented consistently, or when the if, for, while or def line that opens the block is missing its colon.

55for vs while

Use for when you know how many times to repeat, like 10 times. Use while when repeating depends on a condition that can change, like until the user types quit.

57infinite loop

A while loop whose condition never becomes False, often because the loop variable is never updated. Stop it with the Stop button, or fix it by changing the variable inside the loop.

58if inside a loop

An if indented inside a loop's block is checked again on every repetition, so each pass can make a different decision.

59while guess != secret:

The loop at the heart of a guessing game. It keeps asking until the guess matches the random secret number. If/elif/else gives hints and a counter adds 1 each turn.

60decomposition

Splitting a big problem into smaller sub-problems, such as input, process and output. Each part can be solved on its own, then the solutions are combined.

64procedure vs function

A procedure carries out a task without returning a value, while a function returns a value to the code that called it, so the result can be stored or used.

65def main():

A function that calls other small functions, each doing one job, so the program is built in parts. Each box in a hierarchy chart can become one function.

69global

A keyword used inside a function so it can assign to a variable defined outside all functions, instead of creating a new local variable with the same name.

70if ask(q, a): score += 1

Calls a function that returns True for a right answer, then adds 1 to score when it does. Put this in a loop to ask every question and total the quiz score.

74one-dimensional array

A named, ordered collection of elements of the same data type. Each element is reached by its index, its position number (0-based in Python, often 1-based in pseudocode).

75for item in my_list:

Runs the indented block once for each value in the list. The variable item holds the current value each time round, starting with the first and finishing with the last.

76for i in range(len(arr)):

Loops i through every index of arr, so arr[i] can be read or changed and you know each element's position. Used for totals, finding the largest value and editing in place.

77scores[1]

Accesses the array element at index 1, using square brackets to specify the position.

79record

A data structure that groups related fields of different data types into one item describing one thing, e.g. a student's name (String), age (Integer) and enrolled (Boolean).

80student.name

Accesses the name field of the student record, using a dot to connect the record to its field.

82library

A collection of ready-made code you can reuse. The standard library comes with Python; third-party libraries are made by others and must be installed separately (e.g. with pip).

83import math

Loads Python's math module, giving you extras like math.sqrt(), math.pi, math.ceil() and math.floor() that basic operators don't have. Call them with the math. prefix.

84import random

Gives your program the random module. Then random.randint(1, 6) gives a random whole number from 1 to 6, and random.choice(my_list) picks a random item from a list.

88GUI

A graphical user interface: windows and controls like buttons and text boxes the user clicks or types in. The program waits for events, such as a click, and responds to each one.

89root = tk.Tk()

Creates the main tkinter window after import tkinter as tk. Call root.mainloop() at the end to show the window and wait for events like clicks.

90event trigger

An action on an interface object, such as a click or key press, that starts a response in the program. The code that responds is called an event handler.

91tk.Button(root, text='Go', command=show)

Makes a button that runs the function show when clicked. Write the function name with no brackets, or it runs straight away instead of on click.

92root.bind('<KeyPress>', handler)

Links a key press to a handler function. Each time a key is pressed, tkinter calls handler(event), and event.keysym tells you which key it was.

93widget.bind('<Button-1>', handler)

Runs the handler function when the left mouse button is clicked on that widget. The handler receives an event with event.x and event.y. Use '<Double-Button-1>' for a double click.

94label.config(text='Done')

A handler runs when an event happens and can call config() to change the interface, such as updating a label's text to give the user feedback.

95internal documentation

Explanation written inside the code to say what it does and why, so other programmers can understand, fix and update it later.

96scores = [] # marks for each student

A comment beside a variable, list, record or class that says what it stores and how it is used, so other programmers can understand the data and code structures.

97header comment

A comment at the top of a file that records the program's purpose, author, date and any changes made, so others can understand and maintain the code.

98"""docstring"""

A triple-quoted string placed first in a function or class that describes its purpose, parameters and return value. It is internal documentation.

99naming convention

An agreed pattern for naming variables, functions, classes and constants so code is consistent, uses meaningful names and is easy to read.

100snake_case

A naming style where all letters are lowercase and words are joined by underscores, like student_score. Python uses it for variables and functions, and it should be used consistently.

101readable code

Code that people can quickly understand, using clear names, consistent indentation and spacing, short functions with no repeated code, and helpful comments.

102refactoring

Rewriting working code to make it clearer or simpler (e.g. renaming variables, moving repeated lines into a function) without changing what it does, then re-running tests.

103dependability

A dependable program works correctly and reliably every time, even when users enter unexpected or invalid input, because it handles errors instead of crashing.

104while not valid:

A loop that keeps asking for input again until the answer is valid, so bad data (like an age of -5) can't get into your program. Show an error message each time.

105efficiency

How well a solution uses resources such as time, processing, memory, storage and user effort to do its job. An efficient solution is fast, light on memory and storage, and saves the user time.

106optimisation

Changing code so it runs faster, uses less memory or is easier to read, without changing what it does. For example, removing repeated code or using a built-in function.

107KISS

Keep It Simple: solve the problem with the clearest, shortest logic, avoiding extra complexity and giving each function one job, so code is easier to read, test and maintain.

108machine independent

A language whose code can run on different types of computer. High-level languages are machine independent (portable); low-level languages are machine dependent.

109follow an algorithm

To carry out each step exactly as written, in order, without skipping steps or guessing. You can track values on paper, check the final result, or act it out with a partner.

110trace table

A table with one row per loop repeat. Record the IF condition result, change only the variables the branch updates, copy the rest down, and note any output.

111normal, boundary and invalid data

A good test set uses normal data (typical values), boundary data (values at the edges of a range) and invalid data (values that should be rejected), so every path in an algorithm is checked.

112test case

A chosen input paired with the output you expect. Run the program with it, compare the real output to the expected result in your test table, then record pass or fail.

113assert

Checks a condition is True, like assert add(2, 3) == 5. If the result is not what you expected, it raises an AssertionError, so test cases can run automatically.

114unit testing

Testing one function or class on its own, with its own test table, before joining it to the rest of the program, so a failing test points to that module.

115logic error

A mistake in an algorithm's steps. It still runs to the end with no warning, but gives the wrong output. Only tracing or testing shows it, unlike a syntax error that breaks the writing rules.

116runtime error

An error that stops a program while it runs, shown as a named error like NameError, ValueError or ZeroDivisionError. Read the message to find the problem.

117TypeError

A runtime error when an operation gets the wrong data types, like '5' + 3 (string plus integer). Fix it by converting with int() or str(), e.g. int(input()).

118print(variable)

Debugging tool: print a variable at key points, then compare each value with your trace table of what it should be. The first mismatch shows where the bug is.

119# (commenting out)

Putting # in front of a line, or a selected block, stops Python running it. Use this to isolate a bug, then remove the # to restore the code.

120breakpoint

A marker set on a line of code that pauses the program there when it runs, so you can inspect variables and step through. Set one by clicking beside the line; click again to remove it.

121step over

Run the next line only, then pause again. Check the variable watch panel after each step to see which line first gives a wrong value.

122bug

A mistake in an algorithm. Follow the steps until the result goes wrong, then fix that step. It might be in the wrong order, missing, or unclear.

123regression testing

After fixing a bug, rerun the failed test and all earlier tests, because a fix can break code that used to pass.