#syntax: lambda arguments : expression A lambda function that adds two numbers:
add = lambda x, y: x + y
print(add(4, 9))
A lambda function that multiply two numbers:
multiply = lambda a, b: a * b
print(multiply(3, 8)

def countdown(n):
if n <= 0:
print("Done!")
else:
print(n)
countdown(n - 1)
countdown(5)

def factorial(n):
#Base case
if n == 0 or n == 1:
return 1
#Recursive case
else:
return n * factorial(n - 1)
print(factorial(5))

def fibonacci(n):
if n <= 1:
return n
else:
return fibonacci(n - 1) + fibonacci(n - 2)
print(fibonacci(7))

Data stracture & Algorithm.

What is Time Complexity?
Time Complexity tells us:
How the running time of an algorithm grows as input size increases. NB: We don't measure time in seconds.
We measure number of operations.

What is Space Complexity?
Space Complexity tells us:
How much extra memory an algorithm uses as input size increases.
Why we need Complexity?
Imagine two programs solving the same problem:
Program A → works fast for small input but slow for large input
Program B → works fast even for large input
👉 Complexity helps us choose the better one.

many of us know that we can use timers to test the speed of our code. But this raises a couple problems. The other main problem being that this still does not give us an objective way to talk about the difference between two blocks of code. This is exactly where Big O Notation comes into play. It provides a way for us to communicate the efficiency of our code in a way that is consistent and clear. So then what do we use if not time?👇 The simple answer is counting operations.