funwithalgorithms.pptx

extract cells with a given color range
schedule jobs on azure batch in the
greenest and cheapest way
find the direction of moving objects
remove the background from a video

I’m thinking of
a number 1-100
1-100
Hmm… 50?
HIGHER
51-100 .. 75?
76-100 .. 88?
76-87 .. 81?
82-87 .. 84?
85-87 .. 86?
85-85 .. 85!!!
higher
lower
higher
higher
lower

1, 2, 3, 4, 5, 6, 7, 8, 9,
...,85
O(n)

50, 75, 88, 81, 84, 86,
85
log2(100) = 6.64
2^6 = 64
2^7 = 128
O(log n)

log2(100) = 7
log2(1 000 000) = 20
log2(1 000 000 000) = 29
1, 2, 3, 4, 5, ..., 1 000
000

Find 7 – in a sorted list
0 1 2 3 4 5 6 7
8
[ 1 3 7 8 10 11 15
16 17 ]

8:00
3 6 7 11
2 bph 2 + 3 + 4 + 6
= 15h
3 BPH 1 + 2 + 3 + 4
= 10h
4 BPH 1 + 2 + 2 + 3
1 bph 3 + 6 + 7 +
11 = 27h

10 000 piles and 1 000 000 000 bananas in each!!!

8:00
3 6 7 11
2 bph 2 + 3 + 4 + 6
= 15h …
11 BPH 1 + 1 + 1 + 1
1 bph 3 + 6 + 7 +
11 = 27h
P * M calculations
10 000 piles * 1 000 000 000 hours
= 10 000 000 000 000 calculations
M = Max
Bananas
per pile
P = Piles

Koko eating bananas
def get_lowest_speed(piles, hours):
low = 1
high = max(piles)
while low < high:
mid = low + (high - low) // 2
if sum([ceil(pile / speed) for pile in piles]) <= hours:
high = mid
else:
low = mid + 1
return low
O(p * log max(p))
10 000 * 29 vs
10 000 * 1 000 000 000

print(“fruit salad”)
fruits = [“apple”, “banana”, …, “orange”]
print(“step 1”)
…
print(“step 2”)
for fruit in fruits:
print(fruit)
for fruit1 in fruits:
print(fruit1, fruit2)
idx = bsearch(fruits, “banana”) fruits.sort()
O(1)
O(n) O(n^2)
O(log n) O(n * log n)

Sleep sort
def print_number(number):
time.sleep(number)
print(number, end='')
def sleep_sort(numbers):
for number in numbers:
Thread(target=print_number, args=(number,)).start()
O(n)-ish

print(“fruit salad”)
fruits = [“apple”, “banana”, …, “orange”]
print(“step 1”)
…
print(“step 2”)
for fruit in fruits:
print(fruit)
print(fruit1, fruit2)
idx = bsearch(fruits, “banana”) fruits.sort() if “peach” in fruits:
print(“tropical”)
O(1) O(n) O(n^2)
O(log n) O(n * log n) O(n)
O(1)

tree binary search tree
trie / prefix tree linked list

roads = [
[“Oslo”, “Stockholm”],
[“Oslo”, “Copenhagen”],
[“Stockholm”, “Copenhagen”],
[“Stockholm”, “Helsinki”]]
OSLO
STOCKHOLM
Copenhagen
Helsinki
roads = [
[“Oslo”, “Stockholm”, 70],
[“Oslo”, “Copenhagen”, 50],
[“Stockholm”, “Copenhagen”, 30],
[“Stockholm”, “Helsinki”, 21]]

graph =
{
“Oslo”: (“Stockholm”, “Copenhagen”),
“Stockholm”: (“Oslo”, “Copenhagen”, “Helsinki”),
“Copenhagen”: (“Oslo”, “Stockholm”)
“Helsinki”: (“Stockholm”)
}
OSLO
STOCKHOLM
Copenhagen
Helsinki
graph =
{
“Oslo”: { “Stockholm” : 70, “Copenhagen” : 50 },
“Stockholm” : { “Oslo”: 70, “Copenhagen”: 30,
“Helsinki”: 21 },
“Copenhagen”: { “Oslo” : 50, “Stockholm”: 30,}
“Helsinki”: { “Stockholm”: 21 }
}

Depth First Search (DFS)
def dfs(graph, start, goal):
if start == goal:
return 0
visited = set([start])
stack = [(start, 0)]
while stack:
current, steps = stack.pop()
for neighbor in graph[current]:
if neighbor == goal:
return steps + 1
if neighbor not in visited:
visited.add(neighbor)
stack.append((neighbor, steps + 1))
return -1

Breadth First search (BFS)
1 2
2
3
3
4
4
4
def bfs(graph, start, goal):
if start == goal:
return 0
visited = set([start])
queue = deque([(start, 0)])
while queue:
current, steps = queue.popleft()
for neighbor in graph[current]:
if neighbor == goal:
return steps + 1
if neighbor not in visited:
visited.add(neighbor)
queue.append((neighbor, steps + 1))
return -1

Jugs
(5, 0) (2, 3)
(2, 0) (0, 2)
(5, 2) (4, 3)

Breadth First Search (BFS)
Shortest/cheapest path
BFS + state in visited
(i.e. key or no key)
Dijkstra
A*
Bellman-ford (negative)

Course Schedule
Course Pre-req
1 0
2 0
3 1
3 2

Course Schedule – Topo sort
Course Pre-req
1 0
2 0
3 1
3 2
3 1 2 0

Fibonacci
1, 1, 2, 3, 5, 8, 13
def fib(n):
if n <= 1:
return n
return fib(n - 1) + fib(n - 2)

Memoization (Top down)
def fib(n):
if n <= 1:
return n
return fib(n-1) + fib(n-2)
cache = {0: 0, 1: 1}
def fib(n):
if n not in cache:
cache[n] = fib(n-1) + fib(n-2)
return cache[n]
@cache
def fib(n):
if n <= 1:
return n

Tabulation (bottom up)
def fib(n):
if n <= 1:
return n
def fib(n):
fibs = [0, 1]
for i in range(2, n + 1):
fibs.append(fibs[i-1] + fibs[i-2])
return fibs[n]

2 7 1 3 9
0000
0001
0010
0011
0100
0101
0110
0111
1000
1001
1010
1011
1100
1101
1110
1111
0000
0001
0010
0011
0100
0101
0110
0111
1000
1001
1010
1011
1100
1101
1110
1111
O(2 * n) so for n = 100 we have ~ 1.27 * 10 “operations”
n 32
House robber

Maxloot(0) = Loot[0] + Maxloot(2) or Maxloot(1)
0 1 2 3 4
2 7 1 3 9

def rob(loot: list[int]) -> int:
@cache
def max_loot(house_nr):
if house_nr > len(loot):
return 0
rob_current = loot[house_nr] + max_loot(house_nr + 2)
dont_rob_current = max_loot(house_nr + 1)
return max(rob_current, dont_rob_current)
return max_loot(0)
O(n) so for n = 100 we have 100 “operations”
Instead of 1.27 * 10^32

Max sum subarray (of size k=4)
0 1 2 3 4 5 6 7
1 12 -5 -6 50 3 12 -1
1 + 12 - 5 - 6 = 2
12 - 5 - 6 + 50 = 51
-5 - 6 + 50 + 3 = 42
-6 + 50 + 3 + 12 = 59
50 + 3 + 12 - 1 = 64 O((n-k)*k)

Max sum subarray (of size k)
0 1 2 3 4 5 6 7
1 12 -5 -6 50 3 12 -1
1 + 12 - 5 - 6 = 2
2 - 1 + 50 = 51
51 - 12 + 3 = 42
42 - (-5) + 12 = 59
59 - (-6) + (-1) = 64 O(n)

1 0 1 2 1 1
7 5
0 0 0 2 0 1
0 5
Always happy: 1 + 1 + 1 + 7 = 10
Total Happy = 16 (10 + 6) O(n)
Grumpy Bookstore Owner
MAX:
0
2
6
3

MAX:
1
2
3
4
O(n)
Fruits into baskets

Container with most water
1 * 8 =
8
8 * 5 =
40
7 * 7 =
49
8 * 0 =
0
O(n)
MAX:
8
49

funwithalgorithms.pptx

More Related Content

Similar to funwithalgorithms.pptx (20)

More from Tess Ferrandez (15)

Recently uploaded (20)

funwithalgorithms.pptx

Editor's Notes