Data Structures and Algorithms (DSA27) · Week 1

Why this course · Python basics (Lecture 01, Lab 01)

These quizzes are for self-study. Your answers are saved on this device only and are not sent anywhere.

Quizzes Next week Midterm exam simulator Timed test on this lecture

W1-M01 Recall

"Every general-purpose programming language is Turing-complete." What does that tell you?
W1-M02 Recall

Python's type system is best described as:
W1-M03 Apply

What does "3" + 5 do in Python?
W1-M04 Recall

How does Rust manage memory?
W1-M05 Recall

Where and why was C created?
W1-M06 Recall

An Abstract Data Type specifies:
W1-M07 Apply

Which of these is the declarative (comprehension) style from Lecture 01?
W1-M08 Recall

What does the TIOBE index actually count?
W1-M09 Explain

In the course's three levels of knowledge, which is know-why?
W1-M10 Recall

To pass this course, a student needs:
W1-M11 Apply

What is -7 // 2?
W1-M12 Apply

What is -7 % 3?
W1-M13 Apply

What is 2 ** 3 ** 2?
W1-M14 Apply

What is type(8 / 4)?
W1-M15 Apply

With word = "Python", what is word[1:4]?
W1-M16 Apply

What is "Mansoura"[::-2]?
W1-M17 Apply

After a = [1, 2, 3], b = a, b.append(4), what is a?
W1-M18 Apply

After a = [1, 2] and c = a[:], what are c is a and c == a?
W1-M19 Apply

grid = [[0] * 2] * 2, then grid[0][0] = 1. What is grid?
W1-M20 Recall

What is round(2.5) + round(3.5)?
W1-M21 Explain

Why is 0.1 + 0.2 == 0.3 False in Python?
W1-M22 Apply

What happens when you run s = "abc" then s[0] = "z"?
W1-M23 Apply

A function's body is print(width * height) and nothing else. What does x = area(3, 4) store in x?
W1-M24 Apply

What does int("4.5") do?
W1-M25 Explain

In C, reading a[10] from a 5-element array returns whatever happens to be in memory; in Python, a[10] on a 5-element list raises IndexError. Which explanation matches Lecture 01?
W1-M26 Apply

What does Python print for 2 ** 64 + 1?
W1-M27 Explain

Why do the course's exercises never call input()?
W1-M28 Apply

What is f'{7:03d}|{3.14159:.2f}'?
W1-M29 Apply
What does this print?
```
a = [1, 2, 3]
b = a
a = a + [4]
b.append(5)
print(a, b)
```
b = a makes two names for one list. Then a = a + [4] builds a new list and rebinds only a. b still names the old list, so b.append(5) changes only that one. (b) and (c) assume that + changes the list in place; append does, + does not.
W1-M30 Explain

xs = [42, "hello", 3.14] holds an int, a str and a float in one list. Why is that possible?
W1-M31 Recall

Lecture 01 lists three properties we care about in an algorithm. In the lecture's order, they are:
W1-M32 Explain

You time linear and binary search on a sorted list of 20 items, and linear search is faster. Does this contradict "binary search is O(log n), linear search is O(n)"?
W1-M33 Apply

An O(n²) program takes 2 seconds on today's data. The data grows ten times larger. About how long will it take now?
W1-M34 Explain

TIOBE ranked Visual Basic above Rust in September 2026. What does Lecture 01 conclude from rankings like this?
W1-M35 Recall

What is 'a,b,,c'.split(',')?
W1-M36 Explain

A shop stores prices in pounds as float values and adds them up. Why does Lab 01 say not to, and what should it do instead?
W1-M37 Recall

What do 'banana'.find('z') and 'banana'.index('z') do?
W1-M38 Explain

Lecture 01 calls Python's built-in list, dict, sorted and heapq "the honest case against Python — for us". Why are they a problem in this course?
W1-M39 Recall

Which pairing of designer, language and decision is correct?
W1-M40 Explain

Lecture 01 says you cannot write badly-indented Python. Why?
W1-M41 Apply
What does this print?
```
def min_max(a, b):
    if a < b:
        return a, b
    return b, a

result = min_max(9, 2)
print(type(result).__name__, result[0])
```
return a, b returns one value, a tuple. Here 9 < 2 is false, so the second return gives (2, 9), and result[0] is 2. (c) takes the order of the arguments instead of the order returned.
W1-M42 Apply
What does this print?
```
grid = [[0, 0], [0, 0]]
copy = grid[:]
copy[0][0] = 9
copy[1] = [7, 7]
print(grid)
```
grid[:] is a shallow copy: a new outer list holding the same inner lists. copy[0][0] = 9 changes an inner list that both share, so grid sees it. copy[1] = [7, 7] rebinds a slot of the new outer list only, so grid does not see it, which rules out (c). (a) assumes a deep copy.

36 marks

Written questions

10 written questions (36 marks). Write your answer first, then open the model answer and its marking points, and mark yourself honestly: each point is worth about one mark.

Written total: 0 / 36

W1-E1 Explain 4 marks

"All programming languages are the same; only the syntax differs." Explain what is true in this statement and what is wrong with it. Give one concrete example of a design decision that makes two languages genuinely different.
Your answer (saved on this device only)
Model answer and marking points
- True part: general-purpose languages are Turing-complete, so they can all compute the same set of functions.
- What is wrong: equivalence of what can be computed says nothing about the cost — to write, to read and maintain, to run — nor about which mistakes the language lets survive into production.
- A language is a set of design decisions with authors and reasons (language → design → philosophy).
- Example, any one well explained: C trusts the programmer and does no bounds checking, so a[10] on a 5-element array silently corrupts memory, while Python raises IndexError; or Python is strongly typed ("3" + 5 is an error) while JavaScript is weak ("35"); or Rust's ownership versus C's manual free.
W1-E2 Explain 4 marks

Explain the two independent axes of type systems. Place Python and JavaScript on both axes, and show with one expression how their behaviour differs.
Your answer (saved on this device only)
Model answer and marking points
- Static vs dynamic is when types are checked — at compile time, or at run time.
- Strong vs weak is how strictly types are kept apart — refusing, or silently converting.
- Python is dynamic and strong; JavaScript is dynamic and weak.
- "3" + 5: Python raises TypeError; JavaScript returns "35". Neither is a bug — they are different decisions about loud failure versus convenient conversion.
W1-E3 Recall 3 marks

Describe the three approaches to memory management from Lecture 01, naming one language that uses each. Which one does Python use, and why does that make data structures harder to see in Python?
Your answer (saved on this device only)
Model answer and marking points
- Manual (C, C++): the programmer allocates and frees — fast, and the source of many security bugs. Garbage collected (Python, Java, Go): the runtime frees unreachable objects — safe, less control. Ownership (Rust): the compiler proves each allocation is freed exactly once — safe and fast, harder to satisfy.
- Python uses garbage collection (reference counting plus a cycle collector).
- Consequence: removing a node from a linked list is just "stop referring to it" — no free, no visible pointer — so the structure is invisible unless you use the debugger to watch references change.
W1-E4 Explain 4 marks

Distinguish an Abstract Data Type from a data structure. Illustrate with the Stack ADT and two different structures that implement it.
Your answer (saved on this device only)
Model answer and marking points
- ADT: the contract — operations, their meaning, their cost — with nothing about storage.
- Data structure: a concrete arrangement of data in memory that fulfils the contract.
- Stack ADT: push adds, pop removes the most recent, peek looks; all O(1).
- Two structures: a dynamic array with the top at the end; a linked list with the top at the head. Both honest stacks; they differ in memory overhead, cache behaviour and whether one operation can occasionally be slow. Choosing between them is the engineering.
W1-E5 Explain 3 marks

Give two reasons the course uses Python, and the honest drawback of Python for this course. How does the course deal with that drawback?
Your answer (saved on this device only)
Model answer and marking points
- For, any two: the field (research, data, AI/ML) runs on Python; it binds to fast C/C++/CUDA underneath; it reads close to pseudocode, so the algorithm survives onto the page; students meet it again in every program.
- Against: Python already has the structures as built-ins — list, dict, deque, sorted, heapq — which hides exactly what the course studies.
- Remedy: the course reimplements them, and (from Lecture 02) structures may store data only in the course Array, in nodes, or in structures students built — never in list, dict or set.
W1-E6 Explain 3 marks

"In Python a variable is not a box holding a value; it is a name bound to an object." Explain this with a short code example and a diagram, and state one consequence for lists.
Your answer (saved on this device only)
Model answer and marking points
- a = [1, 2, 3] creates a list object and binds the name a to it; b = a binds a second name to the same object — no copy.
- Diagram: two names, a and b, with arrows to one list object.
- Consequence: b.append(4) changes what a shows. To get an independent list, copy it: a[:], a.copy() or list(a) — and that copy is shallow.
W1-E7 Explain 4 marks

"Measure, do not assert." Explain why the course asks you to measure an algorithm's cost, what a measurement shows that a Big-O table does not, and one way a measurement can mislead you, with how to avoid it.
Your answer (saved on this device only)
Model answer and marking points
- Why measure: a claim about cost is a hypothesis. Timing the code over growing n and plotting it against reference curves checks the claim instead of arguing about it (viz.complexity.measure and plot_growth).
- What it shows that Big-O does not: the constant factors, and so the crossover point. Linear search can beat binary search at small n, because binary search does more work per step, even though it wins at scale.
- How it can mislead: one run is noisy, a small n hides the growth, and one machine is not every machine.
- Avoiding it: time many sizes over a wide range, repeat the runs and take the best or the average, and judge the shape (the slope on a log–log plot), not one number.
W1-E8 Explain 3 marks

"print is not return." Explain the difference with a two-line function, say what a test sees in each case, and explain why the exercises use parameters and return rather than input() and print().
Your answer (saved on this device only)
Model answer and marking points
- def f(x): print(x * 2) shows the value on the screen and returns None; def g(x): return x * 2 hands the value back to the caller.
- A test sees only what is returned: assert f(3) == 6 fails, because f(3) is None, although "6" appeared on the screen.
- Exercises take parameters and return results because a test can call them with any input and check the output automatically. A function that calls input() waits for a keyboard that a test does not have, and print() gives the test nothing to check.
W1-E9 Explain 4 marks

"Which language is best?" is not a question. Rewrite it as the real questions it hides, and explain why the ecosystem of a language matters more than its syntax, naming at least three parts of an ecosystem.
Your answer (saved on this device only)
Model answer and marking points
- The real questions: best for what task (firmware, a web service, data analysis…), for whom (one learner, or a large team for ten years), by which measure (speed to write, speed to run, safety, hiring), and when (this project, or one maintained until 2035).
- Change any one of them and the answer changes, so "best" alone has no answer.
- Ecosystem, any three: libraries, tooling (debugger, profiler, package manager, test runner), community (answers already written), interoperability (calling fast code written in another language), longevity.
- Why it beats syntax: you stop noticing syntax after two weeks, but you work inside the ecosystem for years. Whether someone has already solved your problem, well, matters more than how a loop is spelt.
W1-E10 Apply 4 marks

Compare Python's int and float with C's int: what happens when a value gets very large, what that costs, and why 0.1 + 0.2 == 0.3 is False. State the two rules Lab 01 gives for working with floats.
Your answer (saved on this device only)
Model answer and marking points
- C int has a fixed size (usually 32 bits) and silently wraps round when it overflows: 2³¹ - 1 plus 1 becomes -2³¹.
- Python int grows as large as memory allows, so 2 ** 100 is exact. The cost is that arithmetic on huge integers is not O(1): it takes longer as the number of digits grows.
- A float is a 64-bit binary fraction. 0.1, 0.2 and 0.3 have no exact binary form, so 0.1 + 0.2 is 0.30000000000000004. This is not a bug; C, Java and JavaScript do the same.
- Rules: never compare floats with == after arithmetic (round them, or test abs(x - y) < 1e-9), and never store money as a float (store piasters as an int).

Essay, code-tracing, bug-fixing and coding questions are in the week's question bank:

Question bank (PDF) Answers (PDF) Course repository