Python coding and DSA basics quiz

Question 1

What is the average and worst-case time complexity of looking up a key in a Python dict, and what causes the worst case?

Accepted Answer

O(1) average, O(n) worst due to hash collisions

Answer

O(log n) average, O(n) worst

Answer

O(1) always

Answer

O(n) average, O(n^2) worst

Question 2

Why can using a Python list as a queue (pop(0)) be inefficient, and what is the idiomatic fix?

Accepted Answer

list.pop(0) is O(n); use collections.deque for O(1) popleft

Answer

list.pop(0) is O(1) but uses too much memory; use a tuple

Answer

list.pop(0) is O(log n); use a heap

Answer

No problem; list.pop(0) is already O(1)

Question 3

What does this lambda-in-a-comprehension snippet illustrate, and what is the output?

Accepted Answer

[2, 2, 2]

Answer

[0, 1, 2]

Answer

[0, 0, 0]

Answer

Raises NameError

Question 4

In Big-O terms, what is the complexity of the 'in' membership test for a list versus a set, and why does it matter for ML feature filtering?

Accepted Answer

List O(n), set O(1) average

Answer

Both O(1)

Answer

List O(1), set O(n)

Answer

Both O(n)

Question 5

What is the difference between deepcopy and a shallow copy when duplicating a list of NumPy arrays or nested lists?

Accepted Answer

Shallow copy shares inner references; deepcopy recursively duplicates them

Answer

Shallow copy duplicates nested objects; deepcopy does not

Answer

They are identical for nested structures

Answer

Deepcopy shares references; shallow copy duplicates everything

Question 6

Given heapq in Python, which type of heap does it implement and how do you efficiently get the k largest elements from a stream?

Accepted Answer

Min-heap; maintain a size-k min-heap (O(n log k))

Answer

Max-heap; use a size-k max-heap

Answer

Min-heap; sort the whole stream (O(n log n)) only

Answer

Fibonacci heap; O(1) extraction

Question 7

What is the time complexity of the two-pointer technique for finding a pair summing to a target in a sorted array, and why is it better than brute force?

Accepted Answer

O(n) time, O(1) space on a sorted array

Answer

O(n^2), no advantage

Answer

O(log n) time

Answer

O(n log n) time, O(n) space

Question 8

In Python, what is the output and why? print(0.1 + 0.2 == 0.3)

Accepted Answer

False, due to floating-point representation error

Answer

True

Answer

Raises ValueError

Answer

None

Question 9

What does Python's GIL mean for CPU-bound vs I/O-bound parallelism in data pipelines?

Accepted Answer

Threads help I/O-bound but not CPU-bound work; use multiprocessing for CPU

Answer

The GIL speeds up all forms of parallelism

Answer

Threads help CPU-bound but not I/O-bound work

Answer

The GIL only affects asyncio

Question 10

What is the time and space complexity of memoized (top-down) Fibonacci versus naive recursion?

Accepted Answer

Naive O(2^n), memoized O(n) time / O(n) space

Answer

Both O(n)

Answer

Naive O(n), memoized O(2^n)

Answer

Naive O(n^2), memoized O(log n)

Question 11

Why are mutable default arguments dangerous in Python, as in def f(x, acc=[])?

Accepted Answer

The default is created once and shared across calls, accumulating state

Answer

The default is recreated each call, so it's safe

Answer

It raises a SyntaxError

Answer

Python copies the default automatically each call

Question 12

What data structure and approach gives an efficient solution to the 'longest substring without repeating characters' problem, and at what complexity?

Accepted Answer

Sliding window + hashmap, O(n)

Answer

Sorting, O(n log n)

Answer

Brute force pairs, O(n^2)

Answer

Binary search, O(log n)

Question 13

What is the difference between is and == in Python, and why can 'a is b' be True for small integers but False for large ones?

Accepted Answer

== compares value, is compares identity; small ints are interned/cached

Answer

is and == are interchangeable

Answer

is compares value, == compares identity

Answer

is only works on strings

Question 14

How does Python's sort behave with respect to stability, and why does stability matter when sorting records by multiple keys?

Accepted Answer

Stable Timsort, O(n log n) worst case

Answer

Unstable, O(n^2)

Answer

Stable but O(n^2)

Answer

Unstable quicksort, O(n log n)

Question 15

What is the complexity of building a hash-based frequency count of n items and finding the most common element, and which stdlib tool helps?

Accepted Answer

O(n) build with Counter; most_common for the top item

Answer

O(n log n) build; use sorted()

Answer

O(n^2) build; use nested loops

Answer

O(1) build; use a list

Question 16

In a generator-based data pipeline, what is the key memory advantage over building a list, and what is one limitation?

Accepted Answer

Generators use O(1) per-step memory but are single-pass/exhaustible

Answer

Generators are faster to index randomly

Answer

Generators can be iterated infinitely many times

Answer

Generators always store all results

Question 17

What is the time complexity of binary search, and what precondition must hold for it to be correct?

Accepted Answer

O(log n), array must be sorted

Answer

O(n), array must be sorted

Answer

O(log n), no precondition

Answer

O(1), array must be a hash table

Question 18

Explain the difference between __str__ and __repr__ and which one logging/debugging tools rely on.

Accepted Answer

__repr__ is the unambiguous dev representation used by REPL/containers

Answer

__str__ is for developers, __repr__ for users

Answer

They are identical

Answer

__repr__ is only for exceptions

Question 19

What does this code print and why? a = [1,2,3]; b = a; b += [4]; print(a)

Accepted Answer

[1, 2, 3, 4]

Answer

[1, 2, 3]

Answer

Raises TypeError

Answer

[4]

Question 20

When detecting a cycle in a linked list, what algorithm uses O(1) space and how does it work?

Accepted Answer

Floyd's tortoise-and-hare, O(1) space

Answer

Hash set, O(n) space

Answer

Sorting the nodes

Answer

Recursion with a stack

Question 21

What is the difference between @staticmethod, @classmethod, and an instance method in Python?

Accepted Answer

classmethod gets cls, staticmethod gets nothing, instance method gets self

Answer

All three receive self

Answer

staticmethod gets self, classmethod gets nothing

Answer

They are aliases

Question 22

For an LRU cache supporting O(1) get and put, what combination of data structures is required?

Accepted Answer

Hash map + doubly linked list (or OrderedDict)

Answer

A sorted list only

Answer

A binary heap only

Answer

A single array

Question 23

What is the difference between yield and return in a Python function, and what is a generator's state behavior?

Accepted Answer

yield suspends and preserves state; return terminates the function

Answer

yield and return are identical

Answer

return creates a generator; yield does not

Answer

yield can only appear once per function

Question 24

What is the time complexity of merging k sorted lists with a min-heap, and why is it better than concatenating then sorting?

Accepted Answer

O(N log k) with a min-heap

Answer

O(N log N), same as sorting

Answer

O(N*k)

Answer

O(k log N)

Question 25

In Python, what is the result of bool([]), bool({}), bool('0'), and bool(0.0)?

Accepted Answer

False, False, True, False

Answer

All four are False

Answer

All four are True

Answer

True, True, False, True

Question 26

What problem does collections.defaultdict solve over a regular dict, and what is a common pitfall?

Accepted Answer

It auto-creates defaults but accessing missing keys inserts them

Answer

It makes lookups O(1) instead of O(n)

Answer

It prevents all KeyErrors and never modifies the dict

Answer

It sorts keys automatically

Question 27

What is the asymptotic complexity of repeated string concatenation in a loop (s += chunk) and the preferred alternative?

Accepted Answer

Can be O(n^2); use ''.join(list) for O(n)

Answer

Already O(n); no change needed

Answer

O(log n); use a generator

Answer

O(n^2); use a tuple instead

Question 28

When should you prefer BFS over DFS for finding the shortest path in an unweighted graph?

Accepted Answer

BFS finds shortest paths in unweighted graphs (explores by distance)

Answer

DFS always finds shortest paths

Answer

Both guarantee shortest paths equally

Answer

Neither can find shortest paths

Question 29

What does enumerate(iterable, start=1) provide, and why prefer it over manual index counters when processing batches?

Accepted Answer

It yields (index, item) pairs lazily with a configurable start

Answer

It sorts the iterable

Answer

It returns only indices

Answer

It requires a list and computes len() first

Question 30

How do set-based deduplication and order preservation interact in Python?

Accepted Answer

Neither set nor set comprehension preserves order; use dict.fromkeys to keep order

Answer

set preserves order; dict.fromkeys does not

Answer

Both preserve insertion order

Answer

Order preservation requires sorted()

Test yourself