Algorithmic Thinking with Python

Module 1 does two jobs at once. The first half is about how people solve problems — the named strategies (trial and error, heuristics, means-ends analysis, working backward) and the disciplined seven-step process that turns a vague real-world problem into a working program. The second half starts Python: variables, numeric and string types, the math module, basic input and output, and operator precedence. The two halves connect. The strategies tell you what to think; Python is where you write the answer down. Students who skip the first half tend to start typing code before they understand the problem, which is the single most common cause of losing marks in the lab exam.

Module 2 gives you two ways to write down an algorithm before you write code: pseudocode (structured text) and flowcharts (diagrams). Both express the same three constructs — sequence, selection, repetition — which between them are sufficient to express any algorithm. The module is heavily exercise-driven. The syllabus lists nine specific sample problems, and every one of them appears in past papers in some form. Work them by hand; the marks in Part B come from being able to produce correct pseudocode under time pressure, not from recognising it. Flowcharts here are used only for visualising control flow. The syllabus suggests the RAPTOR tool for drawing and running them.

Module 3 is where the course turns from describing algorithms to running them. Everything Module 2 expressed as pseudocode now becomes real Python: if/elif/else, for with range, and while. Then come the sequence types — list, tuple, set, string, dictionary, and NumPy arrays — which is the single biggest jump in the semester. Choosing the right one is a modelling decision, not a syntax decision, and picking wrongly makes a problem far harder than it needs to be. The module closes with decomposition, functions, and recursion. Recursion is the topic S1 students most often say "clicked" only on the second pass, so the notes spend real time on the call stack rather than treating it as an implementation detail.

Module 4 returns to Module 1's question — which strategy does this problem call for? — but now with real algorithms behind each answer. Five approaches: brute force tries everything, divide-and-conquer splits the problem, dynamic programming remembers sub-answers, greedy takes the best-looking step each time, and randomised uses chance deliberately. The syllabus is explicit that this is "introductory diagrammatic and algorithmic explanations only — analysis not required". So the notes build intuition for when each approach fits and what it costs, using counted operations and worked traces rather than formal complexity notation. The recursion-versus-dynamic-programming comparison uses Fibonacci, which Module 3 already measured: the naive recursion needs 2,692,537 calls for fib(30). That number is the argument.