🥽 Understanding computer science fundamentals | The Commonplace Book

0. Reading list

Fri, 26 Aug 2022 00:00:00 +0000

B. Courses to take

1. Computer fundamentals

Mon, 01 Aug 2022 00:00:00 +0000

1. Endianness

The order or sequence in which the bytes of a data is stored in a computer memory. It is expressed as big-endian (BE) or little-endian (LE).

Big-endian: The most significant byte (MSB) is stored at the smallest memory address.
Little-endian: The least significant byte (LSB) is stored at the smallest memory address.

2. Stack & Heap: Memory Allocation and management in python

When a variable is declared, for example x=10 and x=y both have the same value memory, i.e both variable points to the same object. Python optimizes memory utilisation by allocating the same object reference to a new variable if object already exists in memory with same value.

Memory address stored by a variable can be found using id().

The order of memory allocation in RAM is as follows (Low to high),

https://courses.engr.illinois.edu/cs225/sp2022/resources/stack-heap/

Heap is responsible to store all the values. A stack stores hold the references to the objects in the heap.

The name heap and stack does not have any relation to the data structure.

3. Processes and Threads

A process is a program that is currently under execution, whereas a thread is an execution entity that reside within a process that can be scheduled for execution. ¹

A thread is an execution unit with its own stack and set of registers that reside in a process. A thread always belongs to exactly one process.

Threads are also known as light-weight processes.

Difference b/w single & multi-threaded process

In a multi-threaded process, each thread has its own stack and registers but shares the same memory. This lets access to code segments, files and data be shared among threads.

4. Mutexes and Semaphores

5.Global Interpreter Lock (GIL)

References

https://afteracademy.com/blog/what-is-a-thread-in-os-and-what-are-the-differences-between-a-process-and-a-thread ↩︎

2. Analyzing Time Complexities

Wed, 10 Aug 2022 00:00:00 +0000

Data Structures

1. Array

Operation	Average case	Worst case	Amortized
Insert	O(n)	O(n)	O(n)
Delete	O(n)	O(n)	O(n)
Access	O(1)	O(1)	O(1)

2. Linked List

Operation	Average case	Worst case	Amortized
Insert	O(1)	O(1)	-
Delete	O(1)	O(1)	-
Access	O(n)	O(n)	-

3. Heap

Operation	Average case	Worst case	Amortized
Insert	O(log n)	O(log n)	O(log n)
Delete	O(log n)	O(log n)	O(log n)
Heapify	O(n)	O(n)	O(n)
Access largest/smallest	O(1)	O(1)	O(1)

4. Hash Table

Operation	Average case	Worst case	Amortized
Insertion	O(1)	O(n)	-
Deletion	O(n)	O(n)	-
Access	O(1)	O(1)	-

5. Binary search tree

Operation	Average case	Worst case	Amortized
Insert	O(logn)	O(n)	-
Delete	O(logn)	O(n)	-
Access	O(logn)	O(n)	-

Algorithms

1. Sorting

Algorithm	Best case	Average case	Worst case	Amortized
Bubble sort	O(n)	-	O(n^2)	-
Quick sort	O(nlogn)	-	O(n^2)	-
Insertion sort	O(n)	-	O(n^2)	-
Merge sort	O(nlogn)	-	O(nlogn)	-
Heap sort	O(nlogn)	-	O(nlogn)	-

2. Searching

Algorithm	Best case	Average case	Worst case	Amortized
Linear	O(1)	-	O(n)	-
Binary	O(1)	-	O(logn)	-

3. Graphs and advanced graphs

Fri, 29 Jul 2022 00:00:00 +0000

Table of Contents

A. General Introduction

A graph is a collection of nodes and edges. Each node is connected to other nodes by edges. The connection between nodes can either be directed or undirected. Furthermore, each edge can even have a weight.

A graph can be represented in a number of ways. I have listed two common representations:

Adjacency List
- All the nodes are stores in a hashmap. The key is the node and the value is an array of all the nodes that are connected to the key node.
Adjacency Matrix
- A 2D array that stores the connections between nodes. The value at index (i,j) is 1 if there is an edge between node i and node j.
- In case of undirected graphs, the value at index (i,j) and (j,i) need not be symmetrical.

The adjacency matrix is a good graph representation, when the graph is dense. On the other hand, the adjacency list is a good representation when the graph is sparse.

Key Ideas:

The number of incoming and outgoing edges of a node is called indegree and outdegree, respectively.
The degree of a node is the number of incoming and outgoing edges.
A directed graph is acyclical if there are no cycles in the graph. That is, all the directed edges in the graph does not form a closed loop.

I. Adjacency List

Time complexities

Operation	Worst-case Time complexity
Add node (N)	`O(1)`
Add edge (E)	`O(1)`
Remove node (N)	`O(N+E)`
Get adjacent nodes	`O(1)`
Check if node is adjacent	`O(n)`

Space complexity: O(N+E)

II. Adjacency Matrix

Time complexities

Operation	Worst-case Time complexity
Add node (N)	`O(N^2)`
Add edge (E)	`O(1)`
Remove node (N)	`O(1)`
Get adjacent nodes	`O(N)`
Check if node is adjacent	`O(1)`

Space complexity: O(N^2)

B. Leetcode problems

133. Clone Graph

Given a reference of a node in a connected undirected graph.

Return a deep copy (clone) of the graph.

Each node in the graph contains a value (int) and a list (List[Node]) of its neighbors.


class Node:
val:int
neighbors: List[Node]

Test case format:

For simplicity, each node’s value is the same as the node’s index (1-indexed). For example, the first node with val == 1, the second node with val == 2, and so on. The graph is represented in the test case using an adjacency list.

An adjacency list is a collection of unordered lists used to represent a finite graph. Each list describes the set of neighbors of a node in the graph.

The given node will always be the first node with val = 1. You must return the copy of the given node as a reference to the cloned graph.

Example:

Image from https://leetcode.com/problems/clone-graph/

Key Ideas

Algorithm used: Depth-first search

Maintain a hashmap to track the clone of each node
use a graph traversal algorithm to clone the graph
- Pop a node from the queue/stack; check if the node has a clone in the hashmap; if not, create a clone and add it to the hashmap
- Iterate through neighbors and check if they have a copy and add it to the clone’s neighbors
- Maintain a visited set to avoid infinite loop
Return the clone of the given node

Code


"""
# Definition for a Node.
class Node:
def __init__(self, val = 0, neighbors = None):
self.val = val
self.neighbors = neighbors if neighbors is not None else []
"""
class Solution:
def cloneGraph(self, node: 'Node') -> 'Node':
# 1. Have a hash map which tracks a new node for every old node
# 2. pop a node from the stack, check if there is a copy in map else, create a new one
# 3. start looping through neighbors and check if they have copy and add it to new node children
if node is None:
return None
old2new = {}
queue = [node]
visited = set()
while queue:
cur_node = queue.pop()
visited.add(cur_node)
if (cur_node in old2new) is False:
old2new[cur_node] = Node(cur_node.val)
new_node = old2new[cur_node]
for n in cur_node.neighbors:
if (n in old2new) is False:
old2new[n] = Node(n.val)
new_n = old2new[n]
new_node.neighbors.append(new_n)
if n not in visited:
queue.append(n)
visited.add(n)
return old2new[node]

994. Rotting Oranges

You are given an m x n grid where each cell can have one of three values:

0 representing an empty cell,
1 representing a fresh orange, or
2 representing a rotten orange.

Every minute, any fresh orange that is 4-directionally adjacent to a rotten orange becomes rotten.

Return the minimum number of minutes that must elapse until no cell has a fresh orange. If this is impossible, return -1.

Example:

Image from https://leetcode.com/problems/rotting-oranges/

Key Ideas

Algorithm used: Multi-source breadth-first search

An easy way to iterate level by level is to use an inner loop to iterate k number of times, where k is length of the queue at the start of inner loop.
```
while queue:
q_len = len(queue)
for _ in range(q_len):
... # do something
```
This formulation can be used for multi-source BFS.
Use a counter variable to track the number of fresh oranges

Code

from collections import deque
from itertools import product
class Solution:
def orangesRotting(self, grid: List[List[int]]) -> int:
time_step = 0
fresh_oranges = 0
m,n = len(grid), len(grid[0])
DIRECTIONS = [(1,0), (0,1), (-1, 0), (0, -1)]
check_valid_coord = lambda x, y: x >=0 and x < m and y >= 0 and y < n
queue = deque([])
for i,j in product(range(m), range(n)):
if grid[i][j] == 2:
queue.append((i,j))
if grid[i][j] == 1:
fresh_oranges += 1
while queue and fresh_oranges > 0:
time_step += 1
q_len = len(queue)
for _ in range(q_len):
x,y = queue.popleft()
for dx, dy in DIRECTIONS:
xx,yy = x+dx, y+dy
if check_valid_coord(xx,yy) and grid[xx][yy] == 1:
grid[xx][yy] = 2
queue.append((xx,yy))
fresh_oranges -= 1
if fresh_oranges > 0:
return -1
return time_step

Time complexity: O(m*n), where m is the number of rows and n is the number of columns.
Space complexity: O(m*n), in worst case, the queue is filled with all the coordinates in the grid.

684. Redundant Connection

In this problem, a tree is an undirected graph that is connected and has no cycles.

You are given a graph that started as a tree with n nodes labeled from 1 to n, with one additional edge added. The added edge has two different vertices chosen from 1 to n, and was not an edge that already existed. The graph is represented as an array edges of length n where edges[i] = [ai, bi] indicates that there is an edge between nodes ai and bi in the graph.

Return an edge that can be removed so that the resulting graph is a tree of n nodes. If there are multiple answers, return the answer that occurs last in the input.

Example 1:

Image from https://leetcode.com/problems/redundant-connection/

Answer: [1,4]

Key Ideas

Algorithm used: Breadth-first search

Represent the graph as an adjacency list
Maintain a results list, which contains the edges that can be removed.
Iterate through the edges
If two nodes are already connected, add the edge to results list
- else: connect the nodes with the edge
return the last element in the results list

Code

from collections import defaultdict, deque
class Graph:
def __init__(self, N:int) -> None:
self.N = N
self.edges = defaultdict(list)
def connect(self, p:int, q:int) -> None:
self.edges[p].append(q)
self.edges[q].append(p)
def is_connected(self, p:int, q:int) -> bool:
if p in self.edges[q]:
return True
queue = deque([p])
visited = set()
while queue:
node = queue.popleft()
visited.add(node)
if node == q:
return True
for child in self.edges[node]:
if child not in visited:
queue.append(child)
visited.add(child)
return False
class Solution:
def findRedundantConnection(self, edges: List[List[int]]) -> List[int]:
n = len(edges)
g = Graph(n)
result = []
for edge in edges:
p = edge[0]
q = edge[1]
connected = g.is_connected(p,q)
if connected is False:
g.connect(p,q)
continue
result.append(edge)
return result[-1]

Time complexity: O(n^2),
Space complexity: O(n^2).

743. Network Delay Time

You are given a network of n nodes, labeled from 1 to n. You are also given times, a list of travel times as directed edges times[i] = (ui, vi, wi), where ui is the source node, vi is the target node, and wi is the time it takes for a signal to travel from source to target.

We will send a signal from a given node k. Return the minimum time it takes for all the n nodes to receive the signal. If it is impossible for all the n nodes to receive the signal, return -1.

Example:

Image from https://leetcode.com/problems/network-delay-time/

Input: times = [[2,1,1],[2,3,1],[3,4,1]], n = 4, k = 2
Output: 2

Key Ideas

Algorithm used: Djikstra algorithm

Use a min-heap to store the nodes and their corresponding time
When iterating through the edges, add the time to the current time and push it to the heap
Use a min_time variable to track the minimum time taken to reach all the node
Finally, check if the all the nodes were visited
- If not, return -1
- Else, return the min_time

Code


import heapq
from collections import defaultdict
class Solution:
def networkDelayTime(self, times: List[List[int]], n: int, k: int) -> int:
graph = defaultdict(list)
for u,v,w in times:
graph[u].append((v,w))
queue = [(0, k)] # time, node
visited = set()
min_time = 0
while queue:
time, node = heapq.heappop(queue)
if node in visited:
continue
visited.add(node)
min_time = max(min_time, time)
for child_node, child_time in graph[node]:
if child_node not in visited:
heapq.heappush(queue, (time+child_time, child_node))
return min_time if len(visited) == n else -1

1584. Min Cost to Connect All Points

You are given an array points representing integer coordinates of some points on a 2D-plane, where points[i] = [xi, yi].

Return the minimum cost to make all points connected. All points are connected if there is exactly one simple path between any two points.

Example:

Image from https://leetcode.com/problems/min-cost-to-connect-all-points/

Input: points = [[0,0],[2,2],[3,10],[5,2],[7,0]]
Output: 20

Image from https://leetcode.com/problems/min-cost-to-connect-all-points/

We can connect the points as shown above to get the minimum cost of 20. Notice that there is a unique path between every pair of points.

Algorithm used: Prim’s Algorithm

Key Ideas:

Goal: Path which connects all the points at the minimum cost
Use a min-heap to store the cost for each node combination that can be explored
Use a set to track the visited nodes
Iterate till the visited set is equal to the number of nodes
At every pop, check if the node is already visited
- If yes, skip the node and continue
- Else, add the node to the visited set
- Add the cost of the node to the path_cost variable
- explore the children

Code


from collections import defaultdict
import heapq
class Solution:
def minCostConnectPoints(self, points: List[List[int]]) -> int:
mhat_dist = lambda x1, y1, x2, y2: abs(x1 - x2) + abs(y1 - y2)
graph = defaultdict(list)
for i, (x1,y1) in enumerate(points):
for j in range(i+1, len(points)):
x2, y2 = points[j]
dist = mhat_dist(x1,y1, x2, y2)
graph[i].append((dist, j))
graph[j].append((dist, i))
queue = [(0,0)]
visited = set()
min_cost = 0
while len(visited) < len(points):
cost, pt = heapq.heappop(queue)
if pt in visited:
continue
visited.add(pt)
min_cost += cost
for w, cpt in graph[pt]:
if cpt not in visited:
heapq.heappush(queue, (w, cpt))
return min_cost

778. Swim in Rising Water

You are given an n x n integer matrix grid where each value grid[i][j] represents the elevation at that point (i, j).

The rain starts to fall. At time t, the depth of the water everywhere is t. You can swim from a square to another 4-directionally adjacent square if and only if the elevation of both squares individually are at most t. You can swim infinite distances in zero time. Of course, you must stay within the boundaries of the grid during your swim.

Return the least time until you can reach the bottom right square (n - 1, n - 1) if you start at the top left square (0, 0).

Example:

Image from https://leetcode.com/problems/swim-in-rising-water/

Input: grid = [[0,1,2,3,4],[24,23,22,21,5],[12,13,14,15,16],[11,17,18,19,20],[10,9,8,7,6]]
Output: 16
Explanation: The final route is shown.
We need to wait until time 16 so that (0, 0) and (4, 4) are connected.

Key Ideas

Algorithm used: Dijkstra’s Algorithm

Use a min-heap to store the nodes and their corresponding time
- At any moment, we can only move to the node with elevation of at most the current time
Traverse till the botton right node is reached and return the time

Code


import heapq
class Solution:
def swimInWater(self, grid: List[List[int]]) -> int:
# (t, (x,y))
# Maintain a min-heap to store the frontier nodes
# - Pop from the min-heap
# - choosing the node which has less wait time compared
n = len(grid)
DIRECTIONS = [(0,1), (1,0), (0,-1), (-1,0)]
queue = [(grid[0][0], (0,0))]
visited = set()
visited.add((0,0))
check_boundaries = lambda x, y: x >= 0 and x < n and y >= 0 and y < n
while queue:
t, (x,y) = heapq.heappop(queue)
if x == n-1 and y == n-1:
break
for dx,dy in DIRECTIONS:
xx = x+dx
yy = y+dy
if check_boundaries(xx,yy) and (xx,yy) not in visited:
heapq.heappush(queue, (max(t, grid[xx][yy]), (xx,yy)))
visited.add((xx,yy))
return t

Time complexity: O(nlogn),
Space complexity: O(n^2).

787. Cheapest Flights Within K Stops

There are n cities connected by some number of flights. You are given an array flights where flights[i] = [fromi, toi, pricei] indicates that there is a flight from city fromi to city toi with cost pricei.

You are also given three integers src, dst, and k, return the cheapest price from src to dst with at most k stops. If there is no such route, return -1.

Example:

Image from https://leetcode.com/problems/cheapest-flights-within-k-stops/

Input: n = 4, flights = [[0,1,100],[1,2,100],[2,0,100],[1,3,600],[2,3,200]], src = 0, dst = 3, k = 1
Output: 700

Explanation: The graph is shown above. The optimal path with at most 1 stop from city 0 to 3 is marked in red and has cost 100 + 600 = 700. Note that the path through cities [0,1,2,3] is cheaper but is invalid because it uses 2 stops.

Key Ideas

Algorithm used: Multisource BFS

Use a multisource BFS to search layer by layer
Maintain a visited array to store the minimum cost to reach a node
- If the cost is greater than the cost in visited, then skip the node
- Else update visited and continue the search

code


from collections import deque, defaultdict
class Solution:
def findCheapestPrice(self,
n: int, flights: List[List[int]], src: int, dst: int, K: int) -> int:
graph = defaultdict(dict)
for p, q, c in flights:
graph[p][q] = c
minCost = float("inf")
queue = deque([(0, src, K+1)])
visited = [float("inf")]*n
visited[src] = 0
while queue:
m = len(queue)
for _ in range(m):
cost, city, k = queue.popleft()
if k < 0 or cost > visited[city]:
continue
if city == dst:
minCost = min(minCost, cost)
visited[city] = cost
for adjcity, price in graph[city].items():
queue.append((price+cost, adjcity, k-1))
if minCost == float("inf"):
return -1
return minCost

127. Word Ladder

A transformation sequence from word beginWord to word endWord using a dictionary wordList is a sequence of words beginWord -> s1 -> s2 -> ... -> sk such that:

Every adjacent pair of words differs by a single letter.
Every si for 1 <= i <= k is in wordList. Note that beginWord does not need to be in wordList.
sk == endWord

Given two words, beginWord and endWord, and a dictionary wordList, return the number of words in the shortest transformation sequence from beginWord to endWord, or 0 if no such sequence exists.

Example:

Input: beginWord = “hit”, endWord = “cog”, wordList = [“hot”,“dot”,“dog”,“lot”,“log”,“cog”]
Output: 5
Explanation: As one shortest transformation is “hit” -> “hot” -> “dot” -> “dog” -> “cog”, return its length 5.

Key Ideas

@Idea The entire problem can be thought of as a graph problem
- The nodes are the words in the wordList
- The edges are the words which differ by a single letter
@Idea Use a BFS to find the shortest path from beginWord to endWord
Create a pattern map; pattern -> List[word]
Perform multi-source BFS to keep track of the number of transformations
- The number of transformations is the layer at which endWord is located from beginWord

Code


class Solution:
def ladderLength(self, beginWord: str, endWord: str, wordList: List[str]) -> int:
"""
@Idea: BFS on the graph, when the endWord is reached return
the level at which it was located.
Algorithm:
1. Create the pattern mapping
2. Perform multi-source BFS from the beginWord
"""
if endWord not in wordList:
return 0
wordList.append(beginWord)
# pattern -> List of all words of the pattern
patternMap = collections.defaultdict(list)
n = len(beginWord)
for word in wordList:
for i in range(n):
pattern = word[:i]+"*"+word[i+1:]
patternMap[pattern].append(word)
transforms = 1
queue = collections.deque([beginWord])
visited = set([beginWord])
while queue:
m = len(queue)
for _ in range(m):
node = queue.popleft()
if node == endWord:
return transforms
for i in range(n):
pattern = node[:i]+"*"+node[i+1:]
for neigh in patternMap[pattern]:
if neigh not in visited:
queue.append(neigh)
visited.add(neigh)
transforms += 1
return 0

4. Heaps / Priority Queues

Tue, 02 Aug 2022 00:00:00 +0000

Table of Contents

A. General Introduction

Heaps are concrete data structures, whereas priority queues are abstract data structures. An abstract data structure determines the interface, while a concrete data structure defines the implementation.¹

https://en.wikipedia.org/wiki/Heap_%28data_structure%29

In a heap tree, the value in a node is always smaller than both of its children. This is called the heap property.

Generally, heaps can be of two types

Min-heap: The smallest element is always at the root of the tree.
Max-heap: The largest element is always at the root of the tree.

Time Complexity

Operation	Worst-case Time complexity
Build a binary heap (heapify)	`O(n)`
Insert an element	`O(log n)`
Delete an element	`O(log n)`
Find the max/min	`O(1)`
Find the kth largest element (max-heap)	`O(k*log(n))`
Heap sort	`O(n*log(n))`

B. Leetcode Problems

1046. Last Stone Weight

You are given an array of integers stones where stones[i] is the weight of the ith stone.

We are playing a game with the stones. On each turn, we choose the heaviest two stones and smash them together. Suppose the heaviest two stones have weights x and y with x <= y. The result of this smash is:

If x == y, both stones are destroyed, and If x != y, the stone of weight x is destroyed, and the stone of weight y has new weight y - x. At the end of the game, there is at most one stone left.

Return the weight of the last remaining stone. If there are no stones left, return 0.

Example:

Input: stones = [2,7,4,1,8,1]
Output: 1
Explanation:
We combine 7 and 8 to get 1 so the array converts to [2,4,1,1,1],
we combine 2 and 4 to get 2 so the array converts to [2,1,1,1],
we combine 2 and 1 to get 1 so the array converts to [1,1,1],
we combine 1 and 1 to get 0 so the array converts to [1] then that’s the value of the last stone.

Key Ideas:

the default implementation in heapq is min-heap
- so the values are made negative to make them max-heap
When pushing and popping to the heap, the value is negated

Code


import heapq
class Solution:
def lastStoneWeight(self, stones: List[int]) -> int:
stones = [-1*stone for stone in stones]
heapq.heapify(stones)
while len(stones) > 1:
s1 = -1 * heapq.heappop(stones)
s2 = -1 * heapq.heappop(stones) # s2 <= s1
if s1 != s2:
new_stone = -1*(s1 - s2)
heapq.heappush(stones, new_stone)
stones.append(0)
return abs(stones[0])

Time Complexity: O(nlog(n))

703. Kth Largest Element in a Stream

Design a class to find the kth largest element in a stream. Note that it is the kth largest element in the sorted order, not the kth distinct element.

Implement KthLargest class:

KthLargest(int k, int[] nums) Initializes the object with the integer k and the stream of integers nums.
int add(int val) Appends the integer val to the stream and returns the element representing the kth largest element in the stream.

Example:

Input:
[“KthLargest”, “add”, “add”, “add”, “add”, “add”]
[[3, [4, 5, 8, 2]], [3], [5], [10], [9], [4]]

Output:
[null, 4, 5, 5, 8, 8]

Explanation:
KthLargest kthLargest = new KthLargest(3, [4, 5, 8, 2]);
kthLargest.add(3); // return 4
kthLargest.add(5); // return 5
kthLargest.add(10); // return 5
kthLargest.add(9); // return 8
kthLargest.add(4); // return 8

Key Ideas:

Always maintain the list size of k
- use heappop to pop the smallest (n-k) elements
when inserting, pop the last element if the size is greater than k

Code


import heapq
class KthLargest:
def __init__(self, k: int, nums: List[int]):
self.nums = nums
self.k = k
heapq.heapify(self.nums) # O(n)
while len(self.nums) > self.k:
heapq.heappop(self.nums)
def add(self, val: int) -> int:
heapq.heappush(self.nums, val)
if len(self.nums) > self.k:
heapq.heappop(self.nums)
return self.nums[0] # using a min-heap

Time complexity:

The constructor’s time complexity would be O(nlog(n) + (n-k)log(n)) -> O(nlog(n))
The add’s time complexity would be O(log(n)), as the heap is always maintained at size k

973. K Closest Points to Origin

Given an array of points where points[i] = [xi, yi] represents a point on the X-Y plane and an integer k, return the k closest points to the origin (0, 0).

The distance between two points on the X-Y plane is the Euclidean distance (i.e., √(x1 - x2)^2 + (y1 - y2)^2).

You may return the answer in any order. The answer is guaranteed to be unique (except for the order that it is in).

Example:

https://leetcode.com/problems/k-closest-points-to-origin/

Input: points = [[1,3],[-2,2]], k = 1
Output: [[-2,2]]
Explanation:
The distance between (1, 3) and the origin is sqrt(10).
The distance between (-2, 2) and the origin is sqrt(8).
Since the distance between (-2, 2) and the origin is less than the distance between (1, 3) and the origin, (-2, 2) is closer to the origin.

Key Ideas

compute the distance of each point to the origin and store it in a list
To get the k-nearest points, I tried two different methods and both seem to work
1. Method 1: Heaps
  - Use a min-heap to store the k-nearest points
  - pop k elements from the heap and return the points
2. Method 2: Sort
  - Sort the list of distances and return the first k elements

Code - Heap method


import heapq
class Solution:
def kClosest(self, points: List[List[int]], k: int) -> List[List[int]]:
# 1. Compute the euclidean distance from the origin
# 2. heap push all points -> nlogn
# 3. pop `k` elements from the heap -> klogn
distances = []
compute_distance = lambda x,y: (x**2 + y**2)**(0.5)
for x,y in points:
dist = compute_distance(x,y)
heapq.heappush((dist, [x,y]))
k_nearest = []
for _ in range(k):
_, pt = heapq.heappop(distances)
k_nearest.append(pt)
return k_nearest

Time complexity: O((n+k)log(n))

Code - Sort method

import heapq
class Solution:
def kClosest(self, points: List[List[int]], k: int) -> List[List[int]]:
distances = []
compute_distance = lambda x,y: (x**2 + y**2)**(0.5)
for x,y in points:
dist = compute_distance(x,y)
distances.append((dist, [x, y]))
distances = sorted(distances, key=lambda x: x[0]) # nlogn
k_nearest = []
for i in range(k): # k
_, pt = distances[i]
k_nearest.append(pt)
return k_nearest

Time complexity: O(nlog(n))

355. Design Twitter

Design a simplified version of Twitter where users can post tweets, follow/unfollow another user, and is able to see the 10 most recent tweets in the user’s news feed.

Implement the Twitter class:

Twitter() Initializes your twitter object.
void postTweet(int userId, int tweetId) Composes a new tweet with ID tweetId by the user userId. Each call to this function will be made with a unique tweetId.
List<Integer> getNewsFeed(int userId) Retrieves the 10 most recent tweet IDs in the user’s news feed. Each item in the news feed must be posted by users who the user followed or by the user themself. Tweets must be ordered from most recent to least recent.
void follow(int followerId, int followeeId) The user with ID followerId started following the user with ID followeeId.
void unfollow(int followerId, int followeeId) The user with ID followerId started unfollowing the user with ID followeeId.

Example:

Input > [“Twitter”, “postTweet”, “getNewsFeed”, “follow”, “postTweet”, “getNewsFeed”, “unfollow”, “getNewsFeed”]
[[], [1, 5], [1], [1, 2], [2, 6], [1], [1, 2], [1]]

Output [null, null, [5], null, null, [6, 5], null, [5]]

Explanation

Twitter twitter = new Twitter();
twitter.postTweet(1, 5);
// User 1 posts a new tweet (id = 5). twitter.getNewsFeed(1); // User 1’s news feed should return a list with 1 tweet id -> [5]. return [5]
twitter.follow(1, 2); // User 1 follows user 2.
twitter.postTweet(2, 6); // User 2 posts a new tweet (id = 6).
twitter.getNewsFeed(1); // User 1’s news feed should return a list with 2 tweet ids -> [6, 5]. Tweet id 6 should precede tweet id 5 because it is posted after tweet id 5.
twitter.unfollow(1, 2); // User 1 unfollows user 2.
twitter.getNewsFeed(1); // User 1’s news feed should return a list with 1 tweet id -> [5], since user 1 is no longer following user 2.

Key Ideas:

The tricky part of the problem was the use of multiple data structures for the problem.

Use a hashmap to store the tweets tweeted by each userId
Use a hashmap to store the users who are following each userId
when a userId posts a tweet, add the tweet as a tuple to the hashmap with a negative priority value.
To generate a feed, collate all the tweets from the users who are following the userId
- Build a heap from the list of tweets; which takes O(n)
- Pop the top 10 elements from the heap and return the list of tweet ids; which takes O(10*logn) $\approx$ O(logn)

Code


import heapq
from collections import defaultdict
class Twitter:
def __init__(self):
self.usersConn = defaultdict(list)
self.usersTweets = defaultdict(list)
self.tweet_pr = 0
def postTweet(self, userId: int, tweetId: int) -> None:
self.tweet_pr -= 1
self.usersTweets[userId].append((self.tweet_pr, tweetId))
def getNewsFeed(self, userId: int) -> List[int]:
if userId not in self.usersTweets and userId not in self.usersConn:
return []
feed = []
tweets = self.usersTweets[userId].copy()
for friend in self.usersConn[userId]:
tweets.extend(self.usersTweets[friend])
heapq.heapify(tweets)
while len(feed) < 10 and tweets:
obj = heapq.heappop(tweets)
_, tweetId = obj
feed.append(tweetId)
return feed
def follow(self, followerId: int, followeeId: int) -> None:
if followeeId not in self.usersConn[followerId]:
self.usersConn[followerId].append(followeeId) # O(1)
def unfollow(self, followerId: int, followeeId: int) -> None:
if followeeId in self.usersConn[followerId]:
self.usersConn[followerId].remove(followeeId) # O(n)

621. Task Scheduler

Given a characters array tasks, representing the tasks a CPU needs to do, where each letter represents a different task. Tasks could be done in any order. Each task is done in one unit of time. For each unit of time, the CPU could complete either one task or just be idle.

However, there is a non-negative integer n that represents the cooldown period between two same tasks (the same letter in the array), that is that there must be at least n units of time between any two same tasks.

Return the least number of units of times that the CPU will take to finish all the given tasks.

Example:

Input: tasks = [“A”,“A”,“A”,“B”,“B”,“B”], n = 2
Output: 8
Explanation:
A -> B -> idle -> A -> B -> idle -> A -> B
There is at least 2 units of time between any two same tasks.

Key Ideas:

use a max-heap to store the tasks’s counter
have a while loop to simulate time
- pop from the heap, and reduce the counter
  - add to the queue with the time at which it can be popped, with the counter
if the first element in the queue’s time is same as current time
- pop the element and add it to the heap if the counter is non-zero positive
update the time

Code


from collections import deque, Counter
import heapq
class Solution:
def leastInterval(self, tasks: List[str], n: int) -> int:
time = 0
queue = deque([])
max_heap = [-v for _, v in Counter(tasks).items()]
heapq.heapify(max_heap)
while queue or max_heap:
if max_heap:
val = heapq.heappop(max_heap)
val += 1
if val < 0:
queue.append((time+n, val))
if queue and queue[0][0] == time:
_, val = queue.popleft()
heapq.heappush(max_heap, val)
time += 1
return time

295. Find Median from Data Stream

Pattern: When it is required to find the median of a list, where the list grows continuously.

The median is the middle value in an ordered integer list. If the size of the list is even, there is no middle value and the median is the mean of the two middle values.

For example, for arr = [2,3,4], the median is 3.
For example, for arr = [2,3], the median is (2 + 3) / 2 = 2.5.

Implement the MedianFinder class:

MedianFinder() initializes the MedianFinder object.
void addNum(int num) adds the integer num from the data stream to the data structure.
double findMedian() returns the median of all elements so far. Answers within 10^-5 of the actual answer will be accepted.

Example:

Input:
[“MedianFinder”, “addNum”, “addNum”, “findMedian”, “addNum”, “findMedian”]
[[], [1], [2], [], [3], []]
Output:
[null, null, null, 1.5, null, 2.0]

Explanation

MedianFinder medianFinder = new MedianFinder();
medianFinder.addNum(1); // arr = [1]
medianFinder.addNum(2); // arr = [1, 2]
medianFinder.findMedian(); // return 1.5 (i.e., (1 + 2) / 2)
medianFinder.addNum(3); // arr[1, 2, 3]
medianFinder.findMedian(); // return 2.0

Method 1:

Key Ideas:

use an array to store the stream of numbers
appending to the array is O(1)
To find the median, sort the array and compute the median index based on the length of the array; O(nlogn)

Code


import heapq
class MedianFinder:
def __init__(self):
self.data_stream = []
def addNum(self, num: int) -> None:
self.data_stream.append(num) # O(1)
def findMedian(self) -> float:
m = len(self.data_stream)
self.data_stream.sort() # O(nlogn)
idx = m//2
if m % 2 != 0:
median = self.data_stream[idx]
else:
median = (self.data_stream[idx] + self.data_stream[idx-1])/2
return median

Method 2:

Key Ideas:

Maintain two heaps to store the lower and upper halves of the stream of numbers
- The lower half consists of small numbers of data stream; max-heap
- The upper half consists of large numbers of data stream; min-heap
By using two heaps, we have a slight tradeoff in the time complexity of addNum to O(logn) instead of O(1)
- By default, we always add a new number to the small number heap
- After adding the number to the small heap, we can check for certain properties to see if we need to balance the heaps
  - Property 1: Difference between the sizes of the two heaps should be at most 1
    - If it is not satisfied, then pop and push the number to the other heap
  - Property 2: The root of the min-heap should be larger than the root of the max-heap
    - If it is not satisfied
      - pop the root of the max-heap and push it to the min-heap
      - pop the root of the min-heap and push it to the max-heap

Maintain two heaps to optimize findMedian()

As we have two heaps to store the stream of numbers, the time complexity of findMedian is O(1)
- Why? Because we know that the median can be computed from the roots of two heaps, as atmost one heap will have one more element than the other.

Code


import heapq
class MedianFinder:
def __init__(self):
self.sn = [] # heap for small numbers
self.ln = [] # heap for large numbers
def addNum(self, num: int) -> None:
# 1. Add it to sn and check if all the properties are satisfied
# Prop 1: Difference in the sn and ln should at most 1
# Prop 2: Max value in the sn should be less than min value in the ln
heapq.heappush(self.sn, -num)
if len(self.sn) > 1 + len(self.ln):
val = -1*heapq.heappop(self.sn)
heapq.heappush(self.ln, val)
if len(self.ln) > 1 + len(self.sn):
val = heapq.heappop(self.ln)
heapq.heappush(self.sn, -val)
if self.sn and self.ln and self.sn[0] < self.ln[0]:
val = -1*heapq.heappop(self.sn)
heapq.heappush(self.ln, val)
val = heapq.heappop(self.ln)
heapq.heappush(self.sn, -val)
def findMedian(self) -> float:
if len(self.sn) > len(self.ln):
# there are odd number of elements
return -1 * self.sn[0]
elif len(self.ln) > len(self.sn):
return self.ln[0]
v1 = self.ln[0]
v2 = -1*self.sn[0]
return (v1+v2)/2

References

https://realpython.com/python-heapq-module/ ↩︎

5. Trees and Tries

Sat, 30 Jul 2022 00:00:00 +0000

Table of Contents

A. General Introduction

I. Key Methods

Identify the base case - what to do when it reaches the leaf or root node?
Recursive calls to each child node
Identify what needs to be calculated with the information from the child nodes
Return the calculated result

II. Binary Search Tree (BST) Properties

Inorder traversal gives the sorted order of the BST
All values in left subtree are smaller than the current node
All values in right subtree are larger than the current node

B. Leetcode problems

226. Invert Binary Tree

Given the root of a binary tree, invert the tree, and return its root.

Image from https://leetcode.com/problems/invert-binary-tree/

Key Ideas

Invert the tree by swapping the left and right children of each node.

Code


# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution:
def invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
if root is None or root.left == None and root.right == None:
return root
root.left, root.right = root.right, root.left
self.invertTree(root.left)
self.invertTree(root.right)
return root

543. Diameter of Binary Tree

Given the root of a binary tree, return the length of the diameter of the tree.

The diameter of a binary tree is the length of the longest path between any two nodes in a tree. This path may or may not pass through the root.

The length of a path between two nodes is represented by the number of edges between them.

Key Ideas

@BaseCase The diameter of an empty node is 0.
@RecursiveCase The diameter of a node is the maximum of the diameter of its left and right subtrees.
- Return the max height of the subtrees plus 1 (accounts for the edge that connects it to parent node).

code

# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution:
def diameterOfBinaryTree(self, root: Optional[TreeNode]) -> int:
result = 0 # global state that is set at each level
def traverse(root:TreeNode):
if not root:
return 0
rh = traverse(root.right)
lh = traverse(root.left)
nonlocal result
result = max(result, rh+lh)
return max(lh, rh) + 1
traverse(root)
return result

104. Maximum Depth of Binary Tree

Given the root of a binary tree, return its maximum depth.

A binary tree’s maximum depth is the number of nodes along the longest path from the root node down to the farthest leaf node.

Example:

Image from https://leetcode.com/problems/maximum-depth-of-binary-tree/

Input: root = [3,9,20,null,null,15,7]
Output: 3

Key Ideas

@BaseCase The depth of an empty node is 0.
@RecursiveCase Check the max depth of right and left subtrees.
- Return the max of the two plus 1 (To include the height of the current node).

code


class Solution:
def maxDepth(self, root: Optional[TreeNode]) -> int:
if not root:
return 0
depth = 0
if root.right:
rd = self.maxDepth(root.right)
depth = max(depth, rd)
if root.left:
ld = self.maxDepth(root.left)
depth = max(depth, ld)
return depth + 1

110. Balanced Binary Tree

Given a binary tree, determine if it is height-balanced.

For this problem, a height-balanced binary tree is defined as:

a binary tree in which the left and right subtrees of every node differ in height by no more than 1.

Example:

Image from https://leetcode.com/problems/balanced-binary-tree/

Input: root = [3,9,20,null,null,15,7]
Output: true

Key Ideas

@BaseCase The height of an empty node is zero.
@RecursiveCase The height of a node is the maximum of the height of its left and right subtrees.
- At every node, calculate if the difference in height between the left and right subtrees is greater than 1.
  - If so, set the balanced set to false.
- Return the max height of the subtrees plus 1.

code


# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution:
def isBalanced(self, root: Optional[TreeNode]) -> bool:
balanced = True
def dfs(root:TreeNode) -> int:
if root is None:
return 0
lh = dfs(root.left)
rh = dfs(root.right)
if abs(lh-rh) > 1:
nonlocal balanced
balanced = False
return max(lh, rh) + 1
dfs(root)
return balanced

100. Same Tree

Given the roots of two binary trees p and q, write a function to check if they are the same or not.

Two binary trees are considered the same if they are structurally identical, and the nodes have the same value.

Example:

Image from https://leetcode.com/problems/same-tree/

Input: p = [1,2,3], q = [1,2,3]
Output: true

Key Ideas

@BaseCase If both trees are empty, return true.
@RecursiveCase If the trees are not empty, compare the values of the root nodes.
- If they are not equal, return false.
- Otherwise, compare the left and right subtrees.

code


class Solution:
def isSameTree(self, p: Optional[TreeNode], q: Optional[TreeNode]) -> bool:
if not p and not q:
return True
if p and q and p.val == q.val:
l = self.isSameTree(p.left, q.left)
r = self.isSameTree(p.right, q.right)
if l and r:
return True
return False

572. Subtree of Another Tree

Given the roots of two binary trees root and subRoot, return true if there is a subtree of root with the same structure and node values of subRoot and false otherwise.

A subtree of a binary tree tree is a tree that consists of a node in tree and all of this node’s descendants. The tree tree could also be considered as a subtree of itself.

Example:

Image from https://leetcode.com/problems/subtree-of-another-tree/

Input: root = [3,4,5,1,2], subRoot = [4,1,2]
Output: true

Key Ideas

Use isSameTree to check the equality of the trees
@BaseCase If root is empty, return false; because there is no subtree in an empty tree.
@BaseCase If subRoot is empty, return true; because an empty subtree is a subtree of a tree with even one node
@RecursiveCase Check if left subtree or right subtree is the subRoot

Code

class Solution:
def isSameTree(self, p: Optional[TreeNode], q: Optional[TreeNode]) -> bool:
if not p and not q:
return True
if p and q and p.val == q.val:
l = self.isSameTree(p.left, q.left)
r = self.isSameTree(p.right, q.right)
if l and r:
return True
return False
def isSubtree(self, root: Optional[TreeNode], subRoot: Optional[TreeNode]) -> bool:
if not root:
return False
if not subRoot:
return True
if self.isSameTree(root, subRoot):
return True
return self.isSubtree(root.left, subRoot) or self.isSubtree(root.right, subRoot)

102. Binary Tree Level Order Traversal

Given the root of a binary tree, return the level order traversal of its nodes' values. (i.e., from left to right, level by level).

Example:

Image from https://leetcode.com/problems/binary-tree-level-order-traversal/

Input: root = [3,9,20,null,null,15,7]
Output: [[3],[9,20],[15,7]]

Key Ideas

@BaseCase If the root is empty, return an empty list.
Used a multi-source BFS approach to traverse each level of the tree

code


class Solution:
def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
if not root:
return []
result = []
queue = deque([root])
while queue:
layer = []
m = len(queue)
for _ in range(m):
node = queue.popleft()
layer.append(node.val)
# add children
if node.left:
queue.append(node.left)
if node.right:
queue.append(node.right)
result.append(layer)
return result

199. Binary Tree Right Side View

Given the root of a binary tree, imagine yourself standing on the right side of it, return the values of the nodes you can see ordered from top to bottom.

Example:

Image from https://leetcode.com/problems/binary-tree-right-side-view/

Input: root = [1,2,3,null,5,null,4]
Output: [1, 3, 4]

Key Ideas

@BaseCase If the root is empty, return an empty list.
Used a multi-source BFS approach to traverse each level of the tree
- for each level, have a value that is overwritten each node in the level
- At the end of the loop, the value would be the last node at the level

code


class Solution:
def rightSideView(self, root: Optional[TreeNode]) -> List[int]:
if not root:
return []
result = []
queue = deque([root])
while queue:
m = len(queue)
val = None
for _ in range(m):
node = queue.popleft()
val = node.val
if node.left:
queue.append(node.left)
if node.right:
queue.append(node.right)
if val is not None:
result.append(val)
return result

1448. Count Good Nodes in Binary Tree

Given a binary tree root, a node X in the tree is named good if in the path from root to X there are no nodes with a value greater than X.

Return the number of good nodes in the binary tree.

Example:

Image from https://leetcode.com/problems/count-good-nodes-in-binary-tree/

Input: root = [3,1,4,3,null,1,5]
Output: 4
Explanation: Nodes in blue are good.
Root Node (3) is always a good node.
Node 4 -> (3,4) is the maximum value in the path starting from the root.
Node 5 -> (3,4,5) is the maximum value in the path.
Node 3 -> (3,1,3) is the maximum value in the path.

Key Ideas:

@MainCase Pass a maxval argument which is the maximum value in the path
- If the current node’s value is greater than the maxval, then the node is good and the maxval is updated to the current node’s value
- Traverse the right and left subtrees

Code


class Solution:
def goodNodes(self, root: TreeNode) -> int:
if not root.left and not root.right:
return 1
result = 0
def dfs(root:TreeNode, maxval:int) -> None:
if root.val >= maxval:
nonlocal result
result += 1
maxval = root.val
if root.right:
dfs(root.right, maxval)
if root.left:
dfs(root.left, maxval)
dfs(root, root.val)
return result

98. Validate Binary Search Tree

Given the root of a binary tree, determine if it is a valid binary search tree (BST).

A valid BST is defined as follows:

The left subtree of a node contains only nodes with keys less than the node’s key.
The right subtree of a node contains only nodes with keys greater than the node’s key.
Both the left and right subtrees must also be binary search trees.

Example:

Image from https://leetcode.com/problems/validate-binary-search-tree/

Input: root = [2,1,3]
Output: true

Key Ideas:

@BaseCase If the root is empty, return True.
Have a max and min value at each node; If the value of the node is greater than the max value, or less than the min value, then the tree is not a BST
Check the left and right subtrees

code


class Solution:
def isValidBST(self, root: Optional[TreeNode]) -> bool:
if not root.right and not root.left:
return True
def dfs(root:TreeNode, maxval:float, minval:float):
if not root:
return True
if root.val >= maxval or root.val <= minval:
return False
r = dfs(root.right, maxval, root.val)
l = dfs(root.left, root.val, minval)
return r and l
result = dfs(root, float("inf"), float("-inf"))
return result

230. Kth Smallest Element in a BST

Given the root of a binary search tree, and an integer k, return the kth smallest value (1-indexed) of all the values of the nodes in the tree.

Example:

Image from https://leetcode.com/problems/kth-smallest-element-in-a-bst/

Input: root = [3,1,4,null,2], k = 1
Output: 1 \

Key Ideas:

Traverse through the tree in order and return the kth value
Return the k-1th value as it is 1-indexed

code


class Solution:
def kthSmallest(self, root: Optional[TreeNode], k: int) -> int:
heap = []
def traverse(root: TreeNode):
if not root:
return
if root.left:
traverse(root.left)
heap.append(root.val)
if root.right:
traverse(root.right)
traverse(root)
return heap[k-1]

105. Construct Binary Tree from Preorder and Inorder Traversal

Given two integer arrays preorder and inorder where preorder is the preorder traversal of a binary tree and inorder is the inorder traversal of the same tree, construct and return the binary tree.

Example:

Image from https://leetcode.com/problems/construct-binary-tree-from-preorder-and-inorder-traversal/

Input: preorder = [3,9,20,15,7], inorder = [9,3,15,20,7]
Output: [3,9,20,null,null,15,7]

Key Ideas:

Key Idea of the solution

@BaseCase If the length of the preorder and inorder is 0, return None
In preorder the first element is the root of the tree/subtree
- Find the index of the root in inorder and split the preorder and inorder into two subarrays
- Recursively call the function on the subarrays

code


class Solution:
def buildTree(self, preorder: List[int], inorder: List[int]) -> Optional[TreeNode]:
if not preorder and not inorder:
return None
root = TreeNode(preorder[0])
rootIdx = inorder.index(preorder[0])
root.left = self.buildTree(preorder[1:rootIdx+1], inorder[:rootIdx])
root.right = self.buildTree(preorder[rootIdx+1:], inorder[rootIdx+1:])
return root

124. Binary Tree Maximum Path Sum

A path in a binary tree is a sequence of nodes where each pair of adjacent nodes in the sequence has an edge connecting them. A node can only appear in the sequence at most once. Note that the path does not need to pass through the root.

The path sum of a path is the sum of the node’s values in the path.

Given the root of a binary tree, return the maximum path sum of any non-empty path.

Example:

Image from https://leetcode.com/problems/binary-tree-maximum-path-sum/

Input: root = [-10,9,20,null,null,15,7]
Output: 42 Explanation: 5 + 20 + 7 = 42

Key Ideas:

@BaseCase If the root is empty, return 0
The idea is very similar to finding diameter of a tree - we can find the maximum path sum of any path in the tree
- Initalize the max path with root value
- Traverse through the tree and at each node, the max value can be maxvalue or <right-subtree-cost>+ root.val+<left-subtree-cost>
- Return the sum of maximum of left and right subtree max values and the root value

Code


class Solution:
def maxPathSum(self, root: Optional[TreeNode]) -> int:
maxPathVal = root.val
if not root.left and not root.right:
return root.val
def dfs(root) -> None:
if not root:
return 0
lp = max(0, dfs(root.left))
rp = max(0, dfs(root.right))
nonlocal maxPathVal
maxPathVal = max(maxPathVal, lp+rp+root.val)
return max(lp,rp) + root.val
dfs(root)
return maxPathVal

6. Backtracking

Tue, 09 Aug 2022 00:00:00 +0000

Table of Contents

A. General Idea

The key intuition to understand backtracking is to imagine and formulize a problem as decision tree.

Define the base case for the decision tree; Base case determines the terminal condition of a path in a decision tree.
- Out of bounds
- Reach a target sum or value
Decide the actions to take in each node of the decision tree.
- Choose a candidate
- Prune the candidate
Maintain a global state to store the results

B. Leetcode problems

78. Subsets

Given an integer array nums of unique elements, return all possible subsets (the power set).

The solution set must not contain duplicate subsets. Return the solution in any order.

Example 1:

Input: [1,2,3]
Output: [[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]

Key Ideas:

The base case is when the index, i, is out of bounds of the array.
- Append the subset to result
Action: Append a candidate at index i to the subset and recursive call.
- Prune the candidate at index i and recursive call.

code


class Solution:
def subsets(self, nums: List[int]) -> List[List[int]]:
result = []
subset = []
def dfs(i):
if i >= len(nums): # base case - out of bounds
result.append(subset.copy())
return
subset.append(nums[i])
dfs(i+1)
subset.pop()
dfs(i+1)
dfs(0)
return result

90. Subsets II

Given an integer array nums that may contain duplicates, return all possible subsets (the power set).

The solution set must not contain duplicate subsets. Return the solution in any order.

Example 1:

Input: nums = [1,2,2]
Output: [[],[1],[1,2],[1,2,2],[2],[2,2]]

Key Ideas:

The base logic is same as 78. subsets problem.
To handle duplicates, we sort the array to ensure duplicates are arranged consecutively.
- In the case of pruning, ensure to increment i till the next element is different.
  - Why? This ensures that the right subtrees never contain the duplicate element.

code

from typing import List
class Solution:
def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:
result = []
m = len(nums)
# Algorithm:
# 1. Base case: idx >= len(nums): append to the result and return
# 2. Actions:
# 2.1 Include a number and call a recursive fn
# 2.2 Remove the number and call a recursive fn
nums.sort()
def generateSubsets(i,curr):
if i >= m:
result.append(curr.copy())
return
n = nums[i]
curr.append(n)
generateSubsets(i+1, curr)
curr.pop()
while i+1<m and nums[i] == nums[i+1]:
i += 1
generateSubsets(i+1, curr)
generateSubsets(0, []) # generate all the possible subsets without duplicates
return result

39. Combination Sum

Given an array of distinct integers candidates and a target integer target, return a list of all unique combinations of candidates where the chosen numbers sum to target. You may return the combinations in any order.

The same number may be chosen from candidates an unlimited number of times. Two combinations are unique if the frequency of at least one of the chosen numbers is different.

It is guaranteed that the number of unique combinations that sum up to target is less than 150 combinations for the given input.

Example 1:

Input: candidates = [2,3,6,7], target = 7
Output: [[2,2,3],[7]]

Explanation: 2 and 3 are candidates, and 2 + 2 + 3 = 7. Note that 2 can be used multiple times. 7 is a candidate, and 7 = 7. These are the only two combinations.

Key Ideas:

There are multiple base cases for this problem
1. when the sum of the array is greater than the target.
2. when the sum of the array is equal to the target.
The action is to append a candidate to the current subset and recursive call.
- Prune the candidate and recursive call.

code

from typing import List
class Solution:
def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
result = []
def dfs(decision_id:int, current_comb:List[int], current_sum:int):
# Identify and handle the base cases
if current_sum == target:
result.append(current_comb.copy())
return
if current_sum > target or decision_id >= len(candidates):
return
# Make the decisions and update the constraints
current_comb.append(candidates[decision_id])
dfs(decision_id, current_comb, current_sum + candidates[decision_id])
# Undo the decision and traverse another path
current_comb.pop()
dfs(decision_id+1, current_comb, current_sum)
dfs(0, [], 0)
return result

17. Letter Combinations of a Phone Number

Given a string containing digits from 2-9 inclusive, return all possible letter combinations that the number could represent. Return the answer in any order.

A mapping of digits to letters (just like on the telephone buttons) is given below. Note that 1 does not map to any letters.

https://leetcode.com/problems/letter-combinations-of-a-phone-number/

Example 1:

Input: “23”
Output: [“ad”, “ae”, “af”, “bd”, “be”, “bf”, “cd”, “ce”, “cf”]

Key Ideas:

Base case is when the length of the combination is equal to the number of digits
Generate a hashmap which maps the set of characters to the corresponding digit position
Actions: Iterate through the set of character for a particular level and make a recursive call.

code


class Solution:
def letterCombinations(self, digits: str) -> List[str]:
combinations = []
m = len(digits)
if m == 0:
return combinations
digits2char = {
"2":"abc",
"3":"def",
"4":"ghi",
"5":"jkl",
"6":"mno",
"7":"pqrs",
"8":"tuv",
"9":"wxyz",
}
chars = defaultdict(list)
for i, digit in enumerate(digits):
chars[i] = digits2char[digit]
def dfs(comb:str, level:int):
if len(comb) == m:
combinations.append(comb)
return
if len(comb) > m or level > m:
return
charsInLvl = chars[level]
for char in charsInLvl:
dfs(comb+char, level+1)
dfs("", 0)
return combinations

131. Palindrome Partitioning

Given a string s, partition s such that every substring of the partition is a palindrome. Return all possible palindrome partitioning of s.

A palindrome string is a string that reads the same backward as forward.

Example:

Input: s = “aab” Output: [[“a”,“a”,“b”],[“aa”,“b”]]

Key Ideas:

Partition the string into substrings
Check if the substring is a palindrome
- If it is, add it to current_partition, increment idx position in string and call the recursive function
  - Pop the last element from current_partition
@BaseCase If the idx is greater or equal to the length of the string, add the current_partition to the result and return

code


class Solution:
def isPalindrome(self, s:str, l:int, r:int) -> bool:
"""Checks if a string is palindrome"""
while l<r:
if s[l] != s[r]:
return False
l += 1
r -= 1
return True
def partition(self, s: str) -> List[List[str]]:
if len(s) == 1:
return [[s]]
m = len(s)
result = []
current_partition = []
def traversePartition(idx:int):
"""Add palindrome partitions to result list"""
if idx >= m:
result.append(current_partition.copy())
return
for j in range(idx, m):
if self.isPalindrome(s, idx, j):
current_partition.append(s[idx:j+1])
traversePartition(j+1)
current_partition.pop()
# Exp Behav: Add palindrome partitions to the results
traversePartition(0)
return result

79. Word Search

Given an m x n grid of characters board and a string word, return true if word exists in the grid.

The word can be constructed from letters of sequentially adjacent cells, where adjacent cells are horizontally or vertically neighboring. The same letter cell may not be used more than once.

Example:

Image from https://leetcode.com/problems/word-search/

Input: board = [[“A”,“B”,“C”,“E”],[“S”,“F”,“C”,“S”],[“A”,“D”,“E”,“E”]], word = “ABCCED”
Output: true

Key Ideas:

@BaseCase If the current index is greater or equal to the length of the string, return true; That is we have found the entire word through traversal
Iterate through the neighboring cells and call the recursive function if the character at the current index is equal to the character at the current index in the string

code


class Solution:
def exist(self, board: List[List[str]], word: str) -> bool:
m,n = len(board), len(board[0])
s = len(word)
DIRECTIONS = [(1,0), (0,1), (-1,0), (0,-1)]
check_boundaries = lambda x, y: x<m and x>=0 and y<n and y>=0
if s > m*n:
return False
def traverse(i, x, y):
if i >= len(word):
return True
for dx, dy in DIRECTIONS:
xx, yy = x+dx, y+dy
if check_boundaries(xx, yy) and board[xx][yy] == word[i]:
tmp = board[xx][yy]
board[xx][yy] = "#"
if traverse(i+1, xx, yy):
return True
board[xx][yy] = tmp
return False
for i in range(m):
for j in range(n):
if board[i][j] == word[0]:
board[i][j] = "#"
if traverse(1, i,j):
return True
board[i][j] = word[0]
return False

51. N-Queens

The n-queens puzzle is the problem of placing n queens on an n x n chessboard such that no two queens attack each other.

Given an integer n, return all distinct solutions to the n-queens puzzle. You may return the answer in any order.

Each solution contains a distinct board configuration of the n-queens' placement, where 'Q' and '.' both indicate a queen and an empty space, respectively.

Example:

Image from https://leetcode.com/problems/n-queens/

Input: n = 4
Output: [[".Q..","…Q",“Q…”,"..Q."],["..Q.",“Q…”,"…Q",".Q.."]]
Explanation: There exist two distinct solutions to the 4-queens puzzle as shown above

Key Ideas

@BaseCase If the current row equals the last row, then we have reached the end of the board and have successfully placed all the queens.
The key idea is to identify that the negative diagonals follow the pattern row-column and the positive diagonals follow the pattern row+column.
The basic intuition is to place each queen in each row. And then perform a brute-force search to find the correct column in each row.
Maintain three sets for each one of the following:
- Column
- Positive Diagonal
- Negative Diagonal

code


class Solution:
def solveNQueens(self, n: int) -> List[List[str]]:
"""
Although the solution is bruteforce
"""
board = [["."]*n for _ in range(n)]
result = []
col = set()
posDiag = set()
negDiag = set()
def solveByRow(i:int):
if i == n:
solved = ["".join(row) for row in board]
result.append(solved)
return
for j in range(n):
if j in col or (i-j) in negDiag or (i+j) in posDiag:
continue
col.add(j)
negDiag.add((i-j))
posDiag.add((i+j))
board[i][j] = "Q"
solveByRow(i+1)
board[i][j] = "."
posDiag.remove((i+j))
negDiag.remove((i-j))
col.remove(j)
solveByRow(0)
return result

40. Combination Sum II

Given a collection of candidate numbers (candidates) and a target number (target), find all unique combinations in candidates where the candidate numbers sum to target.

Each number in candidates may only be used once in the combination.

Note: The solution set must not contain duplicate combinations.

Example:

Input: candidates = [10,1,2,7,6,1,5], target = 8
Output: [[1,1,6], [1,2,5], [1,7], [2,6]]

Key Ideas:

Sort the array so that duplicate numbers are next to each other
@BaseCase when the sum of the array is greater than the target.
@BaseCase when the sum of the array is equal to the target.
The action is to append a candidate to the current subset and recursive call.
- Prune the candidate and recursive call.
To handle duplicates, we sort the array to ensure duplicates are arranged consecutively.
- In the case of pruning, ensure to increment i till the next element is different.
  - Why? This ensures that the right subtrees never contain the duplicate element.

code


class Solution:
def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:
result = []
candidates.sort()
def findComb(i:int, comb:List[int], total:int):
if total == target:
result.append(comb.copy())
return
if i >= len(candidates) or total > target:
return
c = candidates[i]
comb.append(c)
findComb(i+1, comb, total+c)
comb.pop()
while i < len(candidates)-1 and candidates[i] == candidates[i+1]:
i += 1
findComb(i+1, comb, total)
findComb(0, [], 0)
return result

46. Permutations

Given an array nums of distinct integers, return all the possible permutations. You can return the answer in any order.

Example 1:

Inputs: nums = [1,2,3]
Outputs: [[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]

Key Ideas

It is more of bottom up approach of backtracking
- Keep spiltting the array into two parts and recursively call the function.
@BaseCase When the length of the array is one, return the array as an array.

code


class Solution:
def permute(self, nums: List[int]) -> List[List[int]]:
result = []
if len(nums) == 1:
return [nums.copy()]
for _ in range(len(nums)):
n = nums.pop(0)
perms = self.permute(nums)
for perm in perms:
perm.append(n)
result.extend(perms)
nums.append(n)
return result

7. Computer networks

Mon, 08 Aug 2022 00:00:00 +0000

A. Transport layer services and protocols

The transport layer protocols provide the logical communication between applications/processes running in different hosts.

These protocols run in the end systems and not in the network routers.
- Sender: Breaks the application messages into Segments; passes it to network layers.
  - The segment is further encapsulated into network-layer packets called Datagrams.
    - The datagram is finally passed to the network router.
- Receiver: Receives the segments and re-assembles the application messages; passes it to application layer.

There are different transport layer protocols, each with its own characteristics. The following are the most common ones:

Transmission Control Protocol (TCP)
User Datagram Protocol (UDP)

User Datagram Protocol (UDP)

“No frills,” “bare bones” Internet transport protocol. UDP is a connectionless protocol.

Connectionless:

No handshaking between UDP sender and receiver.
Each segment is handled independently of others.

Why use UDP?

No connection needs to be established which usually creates a delay
Simple: no connection state at sender and receiver
Small segment header
No congestion control: USP can blast away as fast as desired

Most often used for streaming multimedia applications.

Other uses: Domain name system (DNS), Simple network management protocol (SNMP)

Protocol specifications:

Fig 1. UDP segment format

Few notable ports and protocols:

Port number	Protocol	Application
53	`UDP`, `TCP`	Domain name system (DNS)
80	`TCP`	HTTP (WWW)
443	`TCP`	HTTPS (SSL)
16, 384-32, 767	`UDP`	Voice and video

Transmission Control Protocol (TCP)

“Connection-oriented” transport protocol.

Properties:

Point-to-point: One sender, one receiver.
Connection-oriented: Handshaking in it’s sender. receiver state before data exchange.
Full duplex: Bi-directional data flow in same connection
- MSS: Maximum segment size
Reliable, in-order byte stream: Segments are sent in order and acknowledged by receiver.
Flow controlled: Segments are not sent if receiver is not ready.

TCP Segment structure

Includes both source and destination port numbers, checksum.
32 bit sequence number, 32 bit acknowledgment number.
4 bit header length specifies the length of the TCP header in 32-bit words.

8. PEP8 Standards

Tue, 02 Aug 2022 00:00:00 +0000

Imports

Imports are always put at the top of the file, just after any module comments and docstrings, and before module globals and constants.

Imports should be grouped in the following order:

Standard library imports.
Related third party imports.
Local application/library specific imports.

You should put a blank line between each group of imports.

Module Level Dunder Names

Module level “dunders” (i.e. names with two leading and two trailing underscores) such as __all__, __author__, __version__, etc. should be placed after the module docstring but before any import statements except from __future__ imports. Python mandates that future-imports must appear in the module before any other code except docstrings:

"""This is the example module.
This module does stuff.
"""
from __future__ import barry_as_FLUFL
__all__ = ['a', 'b', 'c']
__version__ = '0.1'
__author__ = 'Cardinal Biggles'
import os
import sys

Naming Conventions

b (single lowercase letter)
B (single uppercase letter)
lowercase
lower_case_with_underscores
UPPERCASE
UPPER_CASE_WITH_UNDERSCORES
CapitalizedWords (or CapWords, or CamelCase – so named because of the bumpy look of its letters [4]). This is also sometimes known as StudlyCaps.

Note: When using acronyms in CapWords, capitalize all the letters of the acronym. Thus HTTPServerError is better than HttpServerError.
mixedCase (differs from CapitalizedWords by initial lowercase character!) Capitalized_Words_With_Underscores (ugly!)

In addition, the following special forms using leading or trailing underscores are recognized (these can generally be combined with any case convention):

_single_leading_underscore: weak “internal use” indicator. E.g. from M import * does not import objects whose names start with an underscore.

_single_trailing_underscore: used by convention to avoid conflicts with Python keyword, e.g.

tkinter.Toplevel(master, class_='ClassName')

__double_leading_underscore: when naming a class attribute, invokes name mangling (inside class FooBar, __boo becomes FooBar__boo; see below).

__double_leading_and_trailing_underscore__: “magic” objects or attributes that live in user-controlled namespaces. E.g. init, import or file. Never invent such names; only use them as documented.

Misc

Trailing commas are usually optional, except they are mandatory when making a tuple of one element (and in Python 2 they have semantics for the print statement). For clarity, it is recommended to surround the latter in (technically redundant) parentheses:
```
# Correct:
FILES = ('setup.cfg',)
# Wrong:
FILES = 'setup.cfg',
```

9. Object oriented programming

Thu, 18 Aug 2022 00:00:00 +0000

A. What is OOP?

Object oriented programming (OOP) is a programming paradigm that relies on the concept of classes and objects. The key idea is to structure the program into reusable pieces of code, which are used to create individual instances.

Class: An abstract blueprint used to create more specific, concrete objects.
- They have shared attributes
- classes can also contain functions called methods, available only to objects of that class
Object: An instance of a class.

B. Why use OOP?

Models complex things as reproducible, simple structures.
Reusable.
Secure, protects information through encapsulation.

C. Four principles of OOP

Abstraction: Exposing only high level public methods for accessing an object.
Encapsulation: Hiding implementation details from the user and exposing only selected information.
Inheritance: Child classes inherit data and behaviours from parent class.
Polymorphism: Designing objects to share behaviours. Polymorphism allows the same method to behave differently depending on the type of object.
- Method overriding: A child class can provide a different implementation than its parent class.
- Method overloading: Methods or functions can have same name, but different number and type of parameters.

D. Other concepts

virtual functions: Functions that are present in the parent class and are overridden by the subclass.
Constructor: A special type of method that has the same name as the class and is used to initialize objects of that class.

10. Miscelleaneous problems

Thu, 18 Aug 2022 00:00:00 +0000

1007. Minimum Domino Rotations For Equal Row

In a row of dominoes, tops[i] and bottoms[i] represent the top and bottom halves of the ith domino. (A domino is a tile with two numbers from 1 to 6 - one on each half of the tile.)

We may rotate the ith domino, so that tops[i] and bottoms[i] swap values.

Return the minimum number of rotations so that all the values in tops are the same, or all the values in bottoms are the same.

If it cannot be done, return -1.

Example:

Image from https://leetcode.com/problems/minimum-domino-rotations-for-equal-row/

Input: tops = [2,1,2,4,2,2], bottoms = [5,2,6,2,3,2] > Output: 2 Explanation: The first figure represents the dominoes as given by tops and bottoms: before we do any rotations.
If we rotate the second and fourth dominoes, we can make every value in the top row equal to 2, as indicated by the second figure.

code

from collections import Counter
class Solution:
def minDominoRotations(self, tops: List[int], bottoms: List[int]) -> int:
def minRotationWithRef(arr: List[int], swap:List[int]) -> int:
"""Returns a minimum rotations to normalize arr"""
arrCount = Counter(tops)
arrCount = dict(sorted(arrCount.items(), key=lambda x:x[1], reverse=True))
minTurns = float("inf")
for ref, v in arrCount.items():
turns = 0
for i in range(len(arr)):
if arr[i] == ref:
continue
if arr[i] != ref and swap[i] != ref:
break
turns += 1
if i == len(arr)-1:
minTurns = min(minTurns, turns)
return minTurns
minRotateTops = minRotationWithRef(tops, bottoms)
minRotateBottom = minRotationWithRef(bottoms, tops)
ans = min(minRotateTops, minRotateBottom)
if ans == float("inf"):
return -1
return ans

11. Design principles and patterns

Fri, 19 Aug 2022 00:00:00 +0000

Table of Contents

A. SOLID principles

A mnemonic for 5 design principles of object-oriented programs.

Image from freeCodeCamp

Single responsibility principle (SRP): A class, module, or function in a program should do only one job.
- If a single functionality breaks, you know where the bug will be in the code and can trust that only that class will break.
Open-closed principle (OCP): A program should be open for extension, but closed for modification.
- create entities that can be widely adapted but also remain unchanged.
  - creating duplicate entities with specialized behavior through polymorphism.
Liskov substitution principle (LSP): Objects in a program should be replaceable with instances of their subtypes without altering the correctness of that program.
- In simpler words, any class must be directly replaceable by any of its subclasses without error.
Interface segregation principle (ISP): Many client-specific interfaces are better than one general-purpose interface.

Any unused part of the method should be removed or split into a separate method.
Dependency inversion principle (DIP): One should depend upon abstractions, [not] concretions.
- High level modules should not depend upon low level modules. Both should depend upon abstractions.
- Abstractions should not depend on details. Details should depend on abstractions.
  
  If you minimize dependencies, changes will be more localized and require less work to find all affected components.
- DIP decouples high and low-level components and instead connects both to abstractions.

Summary

Image from devopedia

A1. Achieve Low Coupling

Avoid deep inheritance
- Seperate creating resources from using them
Introduce abstractions
- Use interfaces and abstract classes
Avoid inappropriately intimacy
- What is it? Getting a lot more data than the required data.
Introduce an intermediate data structure

B. Technical Debt

Often technical debt refers to a rushed development process or a lack of shared knowledge among team members. Sometimes it is inevitable.

Knowledge based debt
Design based debt
Code based debt

B1. How to tackle technical debt

Code and architecture refactoring - Resolve code and design debt is organising a refactoring week every X sprints
Start regular technical debt discussions
Start tracking technical debt in your editor
- Documentation
- Code comments
- JIRA tickets (backlogs)

12. Arrays & Hashing

Fri, 19 Aug 2022 00:00:00 +0000

A. General Introduction

Set is implemented as a hash table in python.

Average case: Lookup/insert/delete = O(1)

Worst case: Lookup/insert/delete = O(n); due to hash collision

B. Leetcode problems

128. Longest Consecutive Sequence

Given an unsorted array of integers nums, return the length of the longest consecutive elements sequence.

You must write an algorithm that runs in O(n) time.

Example:

Input: nums = [100,4,200,1,3,2]
Output: 4 Explanation: The longest consecutive elements sequence is [1, 2, 3, 4]. Therefore its length is 4.

Key ideas:

What determines a sequence is the start and end, so create a set and check if the num-1 exists in the set
- If it does not exist, then it is the start of a sequence
  - iteratively increase the length of the sequence till the num is not in the set
  - check max length

code

class Solution:
def longestConsecutive(self, nums: List[int]) -> int:
if not nums:
return 0
history = set(nums)
maxlen = float("-inf")
for num in nums:
if num-1 not in history:
# start of a sequence
length = 0
while (num+length) in history:
length += 1
maxlen = max(maxlen, length)
return maxlen

1. Two Sum

Given an array of integers nums and an integer target, return indices of the two numbers such that they add up to target.

You may assume that each input would have exactly one solution, and you may not use the same element twice.

You can return the answer in any order.

Example:

Input: nums = [2, 7, 11, 15], target = 9
Output: [0, 1]
Explanation: Because nums[0] + nums[1] == 9, we return [0, 1].

Key Ideas:

Use a hash table to store the number and its index
Iterate through the array and check if the number is in the hash table
- If it is, return the index pair
- If it is not, then add the difference between the number and target to the hash table with the index

code


class Solution:
def twoSum(self, nums: List[int], target: int) -> List[int]:
hashmap = {}
for i, val in enumerate(nums):
if val in hashmap:
return [hashmap[val], i]
hashmap[target-val] = i
return -1

13. Sliding Window

Wed, 24 Aug 2022 00:00:00 +0000

A. General Introduction

I. What is it?

A powerful algorithmic mental model.

Usually involves iterable/sequential data structures.
- contiguous sequence of elements
- strings, arrays, linked lists, etc.
Goal: Min, Max, Longest, Shortest, Contained
- Calculating somthing: Average, sum, etc.

II. Lets meet the variants

Some variants of the ‘problem’

Fixed length variant
- max sum of subarray of size k
Dynamic variant
- smallest sum that is greater than or equal to a target
Dynamic variant w/ Auxillary data structure (hashmap, set, etc.)
- longest substring with at most k distinct characters
- string permutation

Commonalities:

Everything is grouped in a sequence

B. Leetcode problems

121. Best Time to Buy and Sell Stock

You are given an array prices where prices[i] is the price of a given stock on the ith day.

You want to maximize your profit by choosing a single day to buy one stock and choosing a different day in the future to sell that stock.

Return the maximum profit you can achieve from this transaction. If you cannot achieve any profit, return 0.

Example:

Input: prices = [7,1,5,3,6,4]
Output: 5
Explanation: Buy on day 2 (price = 1) and sell on day 5 (price = 6), profit = 6-1 = 5.
Note that buying on day 2 and selling on day 1 is not allowed because you must buy before you sell.

Key ideas:

The auxillary data structure is a min_price variable
- We keep track of the minimum price we have seen so far
- We can use this to calculate the maximum profit we can make

code


class Solution:
def maxProfit(self, prices: List[int]) -> int:
profit = 0
minBuy = prices[0]
for sellP in prices:
profit = max(profit, sellP-minBuy)
minBuy = min(minBuy, sellP)
return profit

3. Longest Substring Without Repeating Characters

Given a string s, find the length of the longest substring without repeating characters.

Example:

Input: s = “abcabcbb” Output: 3 Explanation: The answer is “abc”, with the length of 3.

Key ideas:

Move the forward pointer of the window with the outer for loop
- Maintain a set of the characters in the window
- At any point, keep removing the character at the beginning of the window until the window is valid
  - Increment the window size by 1 for each removal
Keep track of the maximum length of the substring

code


class Solution:
def lengthOfLongestSubstring(self, s: str) -> int:
if len(s) == 0:
return 0
start = 0
seen = set()
maxlen = 1
for i in range(len(s)):
while s[i] in seen:
seen.remove(s[start])
start += 1
seen.add(s[i])
maxlen = max(maxlen, len(seen))
return maxlen

567. Permutation in String

Given two strings s1 and s2, return true if s2 contains a permutation of s1, or false otherwise.

In other words, return true if one of s1’s permutations is the substring of s2.

Example:

Input: s1=“ab” s2=“eidbaooo”
Output: true Explanation: s2 contains one permutation of s1 (“ba”).

Key ideas:

Checking permutation of one string in another is essentially checking the anagram in the window
- run a loop while the right pointer is less than the length of s2
  - Use a hashmap to keep track of the characters in the window
  - If it is equal to the hashmap of s1, return true
  - Increment both right and left pointers by 1

code


from collections import Counter
class Solution:
def checkInclusion(self, s1: str, s2: str) -> bool:
if len(s1) > len(s2):
return False
l = 0
r = len(s1)
s1Count = Counter(s1)
while r <= len(s2):
if s1Count == Counter(s2[l:r]):
return True
l += 1
r += 1
return False

76. Minimum Window Substring

Given two strings s and t of lengths m and n respectively, return the minimum window substring of s such that every character in t (including duplicates) is included in the window. If there is no such substring, return the empty string "".

The testcases will be generated such that the answer is unique.

A substring is a contiguous sequence of characters within the string.

Example:

Input: s = “ADOBECODEBANC”, t = “ABC”
Output: “BANC” Explanation: The minimum window substring “BANC” includes ‘A’, ‘B’, and ‘C’ from string t.

Key ideas:

create a hashmap of the characters in t which are the expected characters in a window.
Use a hashmap to keep track of the characters in the window
- use left and right pointers to handle the length of window
- use seen to keep track of the expected characters in the window
  - if seen is equal to the length of hashmap of t then start moving the left pointer
  - maintain the minimum length of the window and its string

code


class Solution:
def minWindow(self, s: str, t: str) -> str:
m,n = len(s), len(t)
if n == 0:
return ""
refCharCount = dict(collections.Counter(t))
expectedKeyChars = len(refCharCount)
seen = 0
windowMap = {} # contains the character count in the current window
l = 0
minMatch, minlen = [0,0], float("inf")
for r in range(m):
c = s[r]
windowMap[c] = windowMap.get(c, 0) + 1
if c in refCharCount and windowMap[c] == refCharCount[c]:
seen += 1
while l <= r and seen == expectedKeyChars:
if minlen > r-l+1:
minMatch = s[l:r+1]
minlen = min(minlen, r-l+1)
windowMap[s[l]] -= 1
# reduce seen if the removed character is in refCharCount
if s[l] in refCharCount and windowMap[s[l]] < refCharCount[s[l]]:
seen -= 1
l += 1
if minlen == float("inf"):
return ""
return minMatch

239. Sliding Window Maximum

You are given an array of integers nums, there is a sliding window of size k which is moving from the very left of the array to the very right. You can only see the k numbers in the window. Each time the sliding window moves right by one position.

Return the max sliding window.

Example:

Input: nums = [1,3,-1,-3,5,3,6,7], k = 3
Output: [3,3,5,5,6,7]

Key ideas:

Maintain a queue which monotonically decreasing; first element is always the maximum
- Before adding the element, keep popping till the element is greater than the current number to be added
  - Add the index of the element to the queue
- If the first element is out of the window, remove it
- If the right index is greater than k-1, append the first element of the queue to the result
  - Increment the left index by 1
deque was used as popleft and pop are O(1) operations

code


class Solution:
def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:
result = []
l = 0
q = collections.deque([])
for r in range(len(nums)):
while q and nums[q[-1]] < nums[r]:
q.pop()
q.append(r)
if l > q[0]:
q.popleft()
if r >= k-1:
result.append(nums[q[0]])
l+=1
return result

424. Longest Repeating Character Replacement

You are given a string s and an integer k. You can choose any character of the string and change it to any other uppercase English character. You can perform this operation at most k times.

Return the length of the longest substring containing the same letter you can get after performing the above operations.

Example:

Input: s = “ABAB”, k = 2
Output: 4 Explanation: Replace the two ‘A’s with two ‘B’s or vice versa.

Key ideas:

window is maintained with left and right pointers
Maintain a dict to keep track of the character count in the window
Find the most frequent character in the window
- If the following condition is satisfied; move the left pointer and reduce the count of that respective character $$\text{window length} - \text{count of most freq char} \gt k$$
check max length of the window and update the result

Code


class Solution:
def characterReplacement(self, s: str, k: int) -> int:
freq = collections.defaultdict(int)
l,r = 0,0
result = 0
while r < len(s):
freq[s[r]] += 1
maxfreq = max(freq.values())
if r-l+1 - maxfreq > k:
freq[s[l]] -= 1
l += 1
result = max(result, r-l+1)
r += 1
return result

14. Databases

Thu, 25 Aug 2022 00:00:00 +0000

Database refers to logical grouping of data that can support the electronic storage and manipulation of data from a computer system.

Typically controlled by a database management system (DBMS)

Over past five decades, databases have evolved from flat file-based types to innovative relational and non-relational databases. Historically, databases have categorized into four groups:

Flat file-based
- Consists of file systems with data maintained in files.
Heirarchical file-based database
- Similar to a flat file-based system but the files share a parent-child relationship.
Relational databases
- Manage data into tables
Non-relational databases
- Customized databases

A. Relational Databases

(aka) relational database management system (RDMB), stores data in tables.

Tables use columns to hep define the information being stored and rows that hold actual data.

Contains atleast column with unique values and that acts as the primary key
- When a table’s primary key is used in a different table, the column in the second table is called a foreign key.

SQL - Structured query language is used to interact with relational databases. It is a standard language for relational database management systems and supports data retrival, query, and manipulation.

Examples:

MySQL
Oracle
Microsoft SQL Server
PostgreSQL
MariaDB

Advantages

Data accuracy - usage of primary and foreign keys help connect and identify databases
Simplified model
Easy access to data
Normalization

I. When to use a relational database

Preferred option for house data that contains a fairly strong structure with rows and columns
Prime candidates - Include data points with a consistent meaning that can be placed into categories and that have relationships
Better choice in scenarios in which repeated data analysis will result in a need to constantly query specific data cross sections.

B. Non-relational Databases

Non-relational databases contain data stored in a non-tabular format and commonly use data structures such as documents or objects.

Two most common types of non-relational databases are:

Document-based
- Stores data in documents
- Supports variety of data types, such as strings, numbers, arrays, and objects
Key-value
- Stores data in key-value pairs

Examples:

MongoDB
Amazon DynamoDB
Redis
Cassandra
ETCD
Google cloud Firestore

Advantages

Simple data management
Greater readability
Enhanced ability
Open-source options
High-performance
Better scalability

I. When to use a non-relational database

Suitable for use cases in which there is a large amount of data that relates to a single topic
- Audience segments
- Unified customer profiles
- Industry-wide trend data
- Application databases
- Large collections of images, text or other data
When data that is stored needs to be flixble in terms of size or shape

15. Operating systems

Fri, 26 Aug 2022 00:00:00 +0000

Table of Contents

A. General Hardware

1. Central Processing Unit (CPU) - An electronic circuitry that executes instructions based on an input of binary data.

It consists of three main components:

Control unit (CU)
- Control and monitor input and output fo data from computer’s hardware
- Primary job: Ensure data is sent to right component, at the right time
  - Ensure all hardware is working on the same schedule
  - Does this with a clock
Arithmetic and Logic Unit (ALU)
- Findamental building block of the CPU, the brains of the entire computer
- Two primary areas
  - Arithmetic - Performs arithmetic operations on data
  - Logic - Performs logical operations on data
Registers (Immediate Access Store)
- Limited space, high-speed memory that CPU can use for quick processing.
- Provide CPU with a place to store and access values that are cruicial to immediate calculations the ALU is processing.

Fundamentally, data is just a series of electrical pulses. These pulses run through different components as a means to process and return data.

2. Memory

Random Access Memory (RAM)
- Used to store and access information on a short-term basis
- primary volatile memory
Static Memory (ROM)
Buses
- It an engineering term for a job-specific high-speed wire.
- Groups of wires that transfer electrical signals either in parallel or in series.
- Three types of buses
  - Data buses - bidirectional; carry data back and forth between processor and other components
  - Address buses - unidirectional; carry a specific addresses in memory
  - Control buses - unidirectional; carry control signals of CU to other components as well as the clock signals for synchronization.

B. Basics of Operating Systems

Take a look at some of the vital functions of an OS:

Process Management
Memory Management
File Management
IO Management
Multitasking
Networking
Security
Providing a user interface

C. Processes and Threads

A process is an abstraction within the operating system that represents the program while it is in execution.

A thread represents the actual sequence of processor instructions that are actively being executed.

Kernel threads are constructed through system calls to the kernel
User threads are constructed using local function calls.

D. Process Scheduling

Computers have a limited amount of resources, be it processor cores, hard drives, or network links, but the number of tasks that it may need to run are ever-growing.

Image from codeacademy.com

Processing States and Queues

Processes exist in multiple states in order to best utilize system resources so that if one process is waiting, another can take its place in the CPU.

States

Ready
Running
Blocked
Waiting
Terminated

Usually, waiting is done in a queue (FIFO).

However, the data structure needs to be modified to accommodate the ready queue.

Different processes may have different priorities, hence a priority queue becomes the more relevant abstraction.

priority is calculated is determined by the scheduling algorithm and is represented by some integer value or category such as low, medium, or high.

E. Synchornization

F. Memory Management

G. File Systems

H. I/O Systems

16. Linked list

Fri, 26 Aug 2022 00:00:00 +0000

A. General Introduction

B. Leetcode Problems

146. LRU Cache

Design a data structure that follows the constraints of a Least Recently Used (LRU) cache.

Implement the LRUCache class:

LRUCache(int capacity) Initialize the LRU cache with positive size capacity.
int get(int key) Return the value of the key if the key exists, otherwise return -1.
void put(int key, int value) Update the value of the key if the key exists. Otherwise, add the key-value pair to the cache. If the number of keys exceeds the capacity from this operation, evict the least recently used key.

The functions get and put must each run in O(1) average time complexity.

Example:

Input:
[“LRUCache”, “put”, “put”, “get”, “put”, “get”, “put”, “get”, “get”, “get”]
[[2], [1, 1], [2, 2], [1], [3, 3], [2], [4, 4], [1], [3], [4]] \

Output
[null, null, null, 1, null, -1, null, -1, 3, 4]

Key Ideas

Use a hashmap to store the key and corresponding node in the doubly linked list.
- Use a two pointers left and right to point to the head and tail of the doubly linked list.
- left pointer is the least recently used node, right pointer is the most recently used node.
When get a node, move the node to the right of the doubly linked list.
When put a node, if the node already exists, move the node to the right of the doubly linked list Otherwise, add the node to the right of the doubly linked list.
When the hashmap reaches capacity, remove the node pointed by the left pointer.

Code


class Node:
def __init__(self, k:int, v:int, prv:"Node"=None, nxt:"Node"=None):
self.key = k
self.val = v
self.prev = prv
self.next = nxt
class LRUCache:
def __init__(self, capacity: int):
"""Initialize a capacity, left and right pointer"""
self.cap = capacity
self.l = Node(0,0) # Least recently used node
self.r = Node(0,0) # Most recently used node
self.l.next, self.r.prev = self.r, self.l
self.cache = {}
def remove(self, node: Node) -> None:
prv, nxt = node.prev, node.next
prv.next, nxt.prev = nxt, prv
def append(self, node: Node) -> None:
next_node = self.r.prev
next_node.next, node.prev = node, next_node
self.r.prev, node.next = node, self.r
def get(self, key: int) -> int:
if key not in self.cache:
return -1
node = self.cache[key]
val = node.val
self.remove(node)
self.append(node)
return val
def put(self, key: int, value: int) -> None:
if key in self.cache:
self.remove(self.cache[key])
node = Node(key, value)
self.cache[key] = node
self.append(node)
if len(self.cache) > self.cap:
lru_node = self.l.next
self.remove(lru_node)
del self.cache[lru_node.key]
# Your LRUCache object will be instantiated and called as such:
# obj = LRUCache(capacity)
# param_1 = obj.get(key)
# obj.put(key,value)

2. Add Two Numbers

You are given two non-empty linked lists representing two non-negative integers. The digits are stored in reverse order, and each of their nodes contains a single digit. Add the two numbers and return the sum as a linked list.

You may assume the two numbers do not contain any leading zero, except the number 0 itself.

Example:

Image from https://leetcode.com/problems/add-two-numbers/

Input: l1 = [2,4,3], l2 = [5,6,4]
Output: [7,0,8]
Explanation: 342 + 465 = 807.

Key Ideas

Use a dummy node to store the head of the linked list.
Use a carry variable to store the carry of the addition.
Run the loop till l1 or l2 are not None or carry is not 0.
Add the values of l1 and l2 and carry and store the sum in sum.
- Create a new node with sum % 10 as the value.
- Update the carry to sum // 10.

Code


# Definition for singly-linked list.
# class ListNode:
# def __init__(self, val=0, next=None):
# self.val = val
# self.next = next
class Solution:
def addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:
dummy = ListNode()
current = dummy
carry = 0
while l1 or l2 or carry:
v1 = l1.val if l1 else 0
v2 = l2.val if l2 else 0
res = v1+v2+carry
val = res % 10
carry = res//10
current.val = val
l1 = l1.next if l1 else None
l2 = l2.next if l2 else None
if l1 or l2 or carry:
current.next = ListNode()
current = current.next
return dummy

17. Intervals

Fri, 26 Aug 2022 00:00:00 +0000

A. General Introduction

B. Leetcode Problems

56. Merge Intervals

Given an array of intervals where intervals[i] = [start_i, end_i], merge all overlapping intervals, and return an array of the non-overlapping intervals that cover all the intervals in the input.

Example:

Input: [[1,3],[2,6],[8,10],[15,18]]
Output: [[1,6],[8,10],[15,18]]
Explanation: Since intervals [1,3] and [2,6] overlaps, merge them into [1,6].

Key Ideas

Sort the intervals by start time
Iterate through the intervals and check if the current interval overlaps with the previous interval
- If it does, set the end time of the interval to the max of both end times
- If it does not, add the interval to the result

Code


class Solution:
def merge(self, intervals: List[List[int]]) -> List[List[int]]:
intervals.sort(key=lambda x: x[0])
result = [intervals[0]]
for start,end in intervals[1:]:
prev_start, prev_end = result[-1]
if start <= prev_end:
result[-1][1] = max(end, prev_end)
else:
result.append([start, end])
return result

919 · Meeting Rooms II

Given an array of meeting time intervals consisting of start and end times [[s1,e1],[s2,e2],…] (si < ei), find the minimum number of conference rooms required.)

Example:

Input: [[0, 30],[5, 10],[15, 20]]
Output: 2 Explanation:
We need two meeting rooms The first room can only accept the meeting in the time range [0, 30] The second room can only accept the meeting in the time range [5, 10] and [15, 20]

Key Ideas

Code


class Solution:
"""
@param intervals: an array of meeting time intervals
@return: the minimum number of conference rooms required
"""
def min_meeting_rooms(self, intervals: List[Interval]) -> int:
s,e = 0,0
count = 0
result = float("-inf")
starts = [i.start for i in intervals]
ends = [i.end for i in intervals]
starts.sort()
ends.sort()
while s < len(intervals):
if starts[s] < ends[e]:
count += 1
s += 1
result = max(result, count)
else:
e += 1
count -= 1
return result

18. Two pointers

Fri, 26 Aug 2022 00:00:00 +0000

A. General Introduction

B. Leetcode Problems

1268. Search Suggestions System

You are given an array of strings products and a string searchWord.

Design a system that suggests at most three product names from products after each character of searchWord is typed. Suggested products should have common prefix with searchWord. If there are more than three products with a common prefix return the three lexicographically minimums products.

Return a list of lists of the suggested products after each character of searchWord is typed.

Example:

Input: products = [“mobile”,“mouse”,“moneypot”,“monitor”,“mousepad”], searchWord = “mouse”
Output: [
    [“mobile”,“moneypot”,“monitor”],
    [“mobile”,“moneypot”,“monitor”],
    [“mouse”,“mousepad”],
    [“mouse”,“mousepad”],
    [“mouse”,“mousepad”]
]
Explanation: products sorted lexicographically = [“mobile”,“moneypot”,“monitor”,“mouse”,“mousepad”]
After typing m and mo all products match and we show user [“mobile”,“moneypot”,“monitor”]
After typing mou, mous and mouse the system suggests [“mouse”,“mousepad”]

Key Ideas

Sort the products lexicographically
Iterate through the searchWord and move the left and right pointer accordingly if the position of current character index does not match with the position of the character in the product
Add the first three words within the left and right pointers

Code


class Solution:
def suggestedProducts(self, products: List[str], searchWord: str) -> List[List[str]]:
result = []
l, r = 0, len(products)-1
products.sort()
for i, c in enumerate(searchWord):
while l<= r and (len(products[l]) <= i or products[l][i] != c):
l += 1
while l<=r and (len(products[r]) <= i or products[r][i] != c):
r -= 1
out = [p for p in products[l:min(l+3,r+1)]]
result.append(out)
return result

28. Find the Index of the First Occurrence in a String

Given two strings needle and haystack, return the index of the first occurrence of needle in haystack, or -1 if needle is not part of haystack.

Example:

Input: needle = “sad”, haystack = “sadbutsad”
Output: 0 Explanation: The first occurrence of “sad” is at index 0.

Key Ideas

start index moves through the string; Have an additional pointer i to move through the haystack until character at i matches the character at index i of needle
If i equals to the len(needle)-1, return the start

Code


class Solution:
def strStr(self, haystack: str, needle: str) -> int:
if len(needle) > len(haystack):
return -1
start = 0
while start < len(haystack):
idx = 0
while idx < len(needle) and start+idx < len(haystack) and haystack[start+idx] == needle[idx]:
idx += 1
if idx-1 == len(needle)-1:
return start
start += 1
return -1

15. 3Sum

Given an integer array nums, return all the triplets [nums[i], nums[j], nums[k]] such that i != j, i != k, and j != k, and nums[i] + nums[j] + nums[k] == 0.

Notice that the solution set must not contain duplicate triplets.

Example:

Input: nums = [-1, 0, 1, 2, -1, -4]
Output: [
[-1, 0, 1],
[-1, -1, 2]
]
Explanation:
nums[0] + nums[1] + nums[2] = 0
nums[1] + nums[2] + nums[4] = 0
nums[0] + nums[3] + nums[4] = 0
The distinct triplets are [-1, 0, 1] and [-1, -1, 2]. Notice that order doesn’t matter.

Key Ideas

To ensure the duplicates have been removed, sort the array; adjacent elements are the same, skip them
- Iterate through the array and perform twosum on the remaining array

Code


class Solution:
def threeSum(self, nums: List[int]) -> List[List[int]]:
idx = 0
result = []
nums.sort()
for idx in range(len(nums)):
if idx > 0 and nums[idx] == nums[idx-1]:
continue
l, r = idx+1, len(nums)-1
while l < r:
threeSum = nums[idx] + nums[l] + nums[r]
if threeSum > 0:
r -= 1
elif threeSum < 0:
l += 1
else:
result.append([nums[idx], nums[l], nums[r]])
l += 1
while l < r and nums[l] == nums[l-1]:
l += 1
return result

11. Container With Most Water

You are given an integer array height of length n. There are n vertical lines drawn such that the two endpoints of the ith line are (i, 0) and (i, height[i]).

Find two lines that together with the x-axis form a container, such that the container contains the most water.

Return the maximum amount of water a container can store.

Notice that you may not slant the container.

Example:

Image from https://leetcode.com/problems/container-with-most-water/

Key Ideas

Have two pointers, left and right at the beginning and the end of the array
- The width of the container is always going to decrease, because we move the pointers towards the center
- Hence, we need to maximize the height of the container
  - Move the pointer with the smaller height towards the center

Code


class Solution:
def maxArea(self, height: List[int]) -> int:
max_area = float("-inf")
l,r = 0, len(height)-1
while l < r:
lh, rh = height[l], height[r]
w = r-l
h = min(lh, rh)
max_area = max(max_area, w*h)
if lh < rh:
l += 1
else:
r -= 1
return max_area

42. Trapping Rain Water

Given n non-negative integers representing an elevation map where the width of each bar is 1, compute how much water it can trap after raining.

Example:

Image from https://leetcode.com/problems/trapping-rain-water/

Key Ideas

At each index, the following is the amount of water that can be trapped
- $\text{min}(\text{max_left}, \text{max_right})-\text{height}[i]$

Code - O(1) Space complexity


class Solution:
def trap(self, height: List[int]) -> int:
m = len(height)
area = 0
leftH = [0]*m
rightH = [0]*m
leftMax = float("-inf")
for i in range(1,m):
leftMax = max(height[i-1], leftMax)
leftH[i] = leftMax
rightMax = float("-inf")
for i in range(m-2,-1, -1):
rightMax = max(height[i+1], rightMax)
rightH[i] = rightMax
for i in range(m):
a = min(leftH[i], rightH[i]) - height[i]
area += max(0, a)
return area

19. Microservices

Fri, 26 Aug 2022 00:00:00 +0000

A. gRPC

Microservices are built in different languages and encompass a function of your business. These services need to talk to each other and need to agree on:

API to exchange data
Data format
Error patterns
Load balancing
etc…

When developing an API, we need to think of multiple things such as data model, endpoints, invoking and handling errors. In addition, we also need to evaluate efficiency, latency and scalability.

I. What is gRPC?

Free and open-source framework developed by Google

gRPC lets you to define REQUEST and RESPONSE for RPC (remote procedure calls) and handles all the rest.

At the core of gRPC, it lets you define the messages and services using Protocol Buffers
Brings a great deal of flexibility and convenience to the table

Example:

syntax = "proto3";
message Greeting {
string first_name = 1;
}
message GreetRequest {
Greeting greeting = 1;
}
message GreetResponse {
string result = 1;
}
service GreetService {
rpc Greet(GreetRequest) returns (GreetResponse) {}
}

Why do we use Protocol Buffers?

Language agnostic
Code is generated for any language
Data is binary and efficiently serialized
Allows for easy API evolution using rules

20. Dynamic programming

Sun, 11 Sep 2022 00:00:00 +0000

21. Deployment strategies

Sun, 21 Aug 2022 00:00:00 +0000

Table of Contents

A. Naive/Basic Deployment

All nodes within a target environment are updated at the same time with a new service or artifact version.

Pros

Simple, fast, and cheap

Cons

Riskiest and does not fall into best practices

B. Multi-service Deployment

All nodes within a target environment are updated with multiple new services simultaneously.

Pros

Simple, fast, cheap, and not as risk-prone as a basic deployment

Cons

Slow to roll back and not outage-proof

C. Rolling Deployment

All nodes are incrementally updated with the service version in integer N batches.

Pros

Relatively simple to roll back, less risky than a basic deployment, and simple to implement

Cons

Updated in batches, rolling deployments require services to support both new and old versions of the service.

D. Blue/Green Deployment

Blue - staging environment
Green - production environment

Utilizes two identical environments, with different versions of an application or service. Quality assurance and user acceptance testing are performed in the staging environment.

User traffic is shifted from the green environment to the blue environment once new changes have been testing and accepted within the blue environment.

Pros

Simple, fast, well-understood, and easy to implement
Rollback is straightforward
Not risky

Cons

Replicating a production environment can be complex and expensive
An outage or issue could have a wide-scale business impact before a rollback is triggered

E. Canary Deployment

Release an application incrementally to a subset of users. All infrastructure in a target environment is updated in small phases (2%, 5%, 10%, …, 100%).

Pros

Test production with real users
Fast and safe to trigger a rollback to a previous version of the application

Cons

Scripting a canary release can be complex: manual verification or testing can take time, and the required monitoring and instrumentation for testing production may involve additional research.

F. A/B Testing

Different versions of the same service run simultaneously as “experiments” in the same environment for a period of time.

Experiments are controls by some mechanism
Commonly, user traffic is routed based on specific rules or user demographics to perform measurements and comparisons
Primarly focused on experimentation and exploration

Pros

Standard, easy and cheap method

Cons

Experiments and tests can sometimes break the application
Scripting or automating AB tests can be complex

22. System Design

Sun, 21 Aug 2022 00:00:00 +0000

Table of Contents

A. Introduction

The three stages to the interview:

Problem: The interviewer gives you a purposely vague task.
Clarification: You show leadership and experience by asking meaningful questions to clarify requirements and performance priorities.
Presentation: You give an impromptu presentation on solutions (probably as you’re thinking of the solution.)

B. Methodology - Framework for System Design

Always start with clarification!
- Ask about the priorities, scale and restrictions of the system
  - How many users?
  - How much data?
  - How many requests per second?
  - Latency requirements?
After understanding the requirements, start with a high level solution
- Start abstract and simple to lay out an end to end solution
- Draw an abstract diagram of the system
- the components should be technology agnostic and abstract away scaling and concrete methods
- eg: Checking whether the system prediction is real time, pre calculated batch or some hybrid
Start filling in some details; architectural components
- eg: How models are delivered to the product? What type of infrastructure is required?
  - Decribe the reasoning behind the design choices
- add data models if necessary
Start with concerete component implementations
- Discuss the tradeoffs of the design choices
- eg: Why did you choose a particular database? Why did you choose a particular language?
Finishing touches

C. ML Model Development

Providing wide array of model types for the problem; it’s good to cover some breadth instead of naming one solution.
Offline training and evaluation
- Data used for training
  - How to deal with data imbalances?
- Metrics used to compare models- Precision, Recall, F1 Score, ROC AUC, etc.
- Evaluation methods
  - K-fold cross validation
  - Training sample selection
Online Evaluation
- Evaluate the model performance via A/B testing
  - What metrics to use?
Model lifecycle management
- Monitoring the model to ensure its health
- Operations to track to keep model performance
  - How to manage the model lifecycle?
  - How to deal with model drift?
  - How to deal with model decay?

I. ML Operational Diffculties

A. ML Drifts

ML Drifts

Concept drift - The learned distribution changes over time due to behavioural changes
Data drift - The learned distribution changes over time due to changes in the data

What to do about it?

Setup data integrity and outlier monitoring
- Data errors slowly degrade
- Missing values
- Broken data pipelines due to bugs or API updates
Setup model drift monitoring

D. Elements of Distributed Systems

Distributed system is an interconnected set of nodes that are linked by a network and share information between them.

I. Microservices

A design paradigm where an application is structured to collect several independent services. The characteristics of these services include:

Independent deployment
Highly scalable
Loosely coupled
Highly maintainable and testable

II. Service Discovery

A service discovery is a mechanism that allows services to find and communicate with each other without hardcoding the location of each other.

Eg: Apache zookeeper, consul, etcd

III. Load Balancing

A device that acts as a reverse proxy and distributes the network traffic across several different servers. There are two distinct types of load balancers:

Layer 4
- Act upon data found in network and transport layer protocols (IP, TCP, FTP, UDP)
Layer 7
- Distributes requests based on application data (HTTP, HTTPS, FTP, SMTP)

Standard algorithms for load balancing:

Round Robin
Least Connections
Least Response Time
Weighted Round Robin

IV. Databases

Refer to the databases page for more details.

V. Caches

A temporary storage with smaller capacity in memory with fast access time.

Client Caching
CDN Caching
Web Server Caching
Database Caching
Application Caching

VI. File System Storage

A file is an unstructured collection of records. Two basic formats:

Block storage - Organize data in blocks on disk
Object storage
- Amazon S3
- Highlty scalable

VII. Message Queues

Lets services to communicate with each other asynchronously. It is a buffer between the producer and consumer.

Producer - The service that produces the message and writes it to the queue
Consumer - The service that consumes the message from the queue and reads it from the queue

Example: RabbitMQ, Kafka

23. Binary Search

Sun, 11 Sep 2022 00:00:00 +0000

Table of Contents

A. Introduction

B. LeeCode Problems

704. Binary Search

Given an array of integers nums which is sorted in ascending order, and an integer target, write a function to search target in nums. If target exists, then return its index. Otherwise, return -1.

You must write an algorithm with O(log n) runtime complexity.

Example:

Input: nums = [-1,0,3,5,9,12], target = 9
Output: 4
Explanation: 9 exists in nums and its index is 4

Code


class Solution:
def search(self, nums: List[int], target: int) -> int:
"""
0, 1, 2, 3, 4, 5
-1, 0, 3, 5, 9, 12
lr
0+5//2 = 2
0+1//2 = 0
"""
if not nums:
return -1
l,r = 0, len(nums)-1
while l <= r:
mid = (l + r)//2
if nums[mid] == target:
return mid
elif nums[mid] < target:
l = mid + 1
else:
r = mid - 1
return -1

74. Search a 2D Matrix

Write an efficient algorithm that searches for a value target in an m x n integer matrix matrix. This matrix has the following properties:

Integers in each row are sorted from left to right
The first integer of each row is greater than the last integer of the previous row

Example:

Input: matrix = [[1,3,5,7],[10,11,16,20],[23,30,34,60]], target = 3
Output: true

Code

Key Ideas

The matrix can be treated as a sorted array
Perform binary search on the rows to find the row where the target can be found
- If the target is greater than the last element of the row, then the target can be found in the next row
- If the target is less than the first element of the row, then the target can be found in the previous row
Implement 1D binary search on the row to find the target


class Solution:
def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:
t,b = 0, len(matrix)-1
while t <= b :
row = (t+b)//2
if matrix[row][-1] < target:
t = row + 1
elif matrix[row][0] > target:
b = row - 1
else:
break
if t > b:
return False
# binary search on the row
l,r = 0, len(matrix[0])-1
while l <= r:
mid = (l+r)//2
if matrix[row][mid] == target:
return True
elif matrix[row][mid] < target:
l = mid + 1
else:
r = mid -1
return False

875. Koko Eating Bananas

Koko loves to eat bananas. There are n piles of bananas, the ith pile has piles[i] bananas. The guards have gone and will come back in h hours.

Koko can decide her bananas-per-hour eating speed of k. Each hour, she chooses some pile of bananas and eats k bananas from that pile. If the pile has less than k bananas, she eats all of them instead and will not eat any more bananas during this hour.

Koko likes to eat slowly but still wants to finish eating all the bananas before the guards return.

Return the minimum integer k such that she can eat all the bananas within h hours.

Example:

Input: piles = [3,6,7,11], h = 8
Output: 4

Key Ideas

The k can be found iteratively using binary search
- Search for a k that satisfies the condition that the number of hours required to eat all the bananas is less than or equal to h
@BaseCase The maximum value of k is the maximum value of the piles

Code


import math
class Solution:
def minEatingSpeed(self, piles: List[int], h: int) -> int:
maxPiles = max(piles)
l,r = 1, maxPiles
res = maxPiles
while l <= r:
hrs = 0
k = (l+r)//2
for pile in piles:
hrs += math.ceil(pile/k)
if hrs <= h:
res = min(res, k)
r = k-1
else:
l = k+1
return res

4. Median of Two Sorted Arrays

Given two sorted arrays nums1 and nums2 of size m and n respectively, return the median of the two sorted arrays.

The overall run time complexity should be O(log (m+n)).

Example:

Input: nums1 = [1,3], nums2 = [2]
Output: 2.00000
Explanation: merged array = [1,2,3] and median is 2.

Key Ideas

@KeyAlgorithm Binary Search on the smaller array to find the partition point
- Move the partition point based on the following condition $$B_{min}\le A_{max} \ \text{and} \ B_{max} \ge A_{min}$$
  - If the above condition is satisfied, then the array is partitioned right
    - Even, median = $(max(A_{min}, B_{min})+min(A_{max}, B_{max}))/2$
    - Odd, median = $min(A_{max}, B_{max})$
  - If $B_{min}$ is greater than $A_{max}$, then l is moved to mid+1
  - If $B_{max}$ is less than $A_{min}$, then r is moved to mid-1

Code


class Solution:
def findMedianSortedArrays(self, nums1: List[int], nums2: List[int]) -> float:
if len(nums1) > len(nums2):
nums2, nums1 = nums1, nums2
m,n = len(nums1), len(nums2)
total_len = m+n
half = total_len//2
l,r = 0, m-1
while True:
a_mid = (l+r)//2
Amin = nums1[a_mid] if a_mid >= 0 else float("-inf")
Amax = nums1[a_mid+1] if a_mid+1 < m else float("inf")
b_mid = half-a_mid-2 # both a_mid and half needs to be zero indexed
Bmin = nums2[b_mid] if b_mid >= 0 else float("-inf")
Bmax = nums2[b_mid+1] if b_mid+1 < n else float("inf")
if Bmin <= Amax and Bmax >= Amin:
if total_len % 2 == 0:
return (max(Amin, Bmin)+min(Amax, Bmax))/2
return min(Amax, Bmax)
elif Bmin > Amax:
l = a_mid + 1
else:
r = a_mid - 1

24. Sorting

Sun, 11 Sep 2022 00:00:00 +0000

Table of Contents

A. Bubble sort

Bubble sort is a simple sorting algorithm that repeatedly steps through the list, compares adjacent elements and swaps them if they are in the wrong order.


def bubble_sort(arr:List[int]) -> List[int]:
for i in range(len(arr)):
for j in range(i+1, len(arr)):
if arr[i] > arr[j]:
arr[i], arr[j] = arr[j], arr[i]
return arr

Time complexity O(n^2)
Space complexity O(1)

B. Selection sort

The selection sort algorithm sorts an array by repeatedly finding the minimum element (considering ascending order) from unsorted part and putting it at the beginning. The algorithm maintains two subarrays in a given array.


def selection_sort(arr:List[int]) -> List[int]:
for i in range(len(arr)):
min_idx = i
for j in range(i+1, len(arr)):
if arr[min_idx] > arr[j]:
min_idx = j
arr[min_idx], arr[i] = arr[i], arr[min_idx]
return arr

Time complexity O(n^2)
Space complexity O(1)

Selection sort performs a smaller number of swaps compared to bubble sort

C. Merge sort

Merge sort is a divide and conquer algorithm that was invented by John von Neumann in 1945. It divides the input array into two halves, calls itself for the two halves, and then merges the two sorted halves.


def merge(a:List[int], b:List[int]) -> List[int]:
p,q = 0,0
res = []
while p < len(a) and q < len(b):
if a[p] < b[q]:
res.append(a[p])
p += 1
else:
res.append(b[q])
q += 1
while p < len(a):
res.append(a[p])
p += 1
while q < len(b):
res.append(b[q])
q += 1
return res
def merge_sort(arr:List[int]) -> List[int]:
if len(arr) < 2:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid+1:])
return merge(left, right)

Time complexity O(nlogn)
Space complexity O(n)

🥽 Understanding computer science fundamentals | The Commonplace Book

0. Reading list

A. System Design Related articles

B. Courses to take

1. Computer fundamentals

1. Endianness

2. Stack & Heap: Memory Allocation and management in python

3. Processes and Threads

4. Mutexes and Semaphores

5.Global Interpreter Lock (GIL)

References

2. Analyzing Time Complexities

Data Structures

1. Array

2. Linked List

3. Heap

4. Hash Table

5. Binary search tree

Algorithms

1. Sorting

2. Searching

3. Graphs and advanced graphs

A. General Introduction

I. Adjacency List

II. Adjacency Matrix

B. Leetcode problems

133. Clone Graph

Key Ideas

994. Rotting Oranges

Key Ideas

684. Redundant Connection

Key Ideas

743. Network Delay Time

Key Ideas

1584. Min Cost to Connect All Points

Key Ideas:

778. Swim in Rising Water

Key Ideas

787. Cheapest Flights Within K Stops

Key Ideas

127. Word Ladder

Key Ideas

4. Heaps / Priority Queues

A. General Introduction

B. Leetcode Problems

1046. Last Stone Weight

Key Ideas:

703. Kth Largest Element in a Stream

Key Ideas:

973. K Closest Points to Origin

Key Ideas

355. Design Twitter

Key Ideas:

621. Task Scheduler

Key Ideas:

295. Find Median from Data Stream

Key Ideas:

Key Ideas:

References

5. Trees and Tries

A. General Introduction

I. Key Methods

II. Binary Search Tree (BST) Properties

B. Leetcode problems

226. Invert Binary Tree

Key Ideas

543. Diameter of Binary Tree

Key Ideas

104. Maximum Depth of Binary Tree

Key Ideas

110. Balanced Binary Tree

Key Ideas

100. Same Tree

Key Ideas

572. Subtree of Another Tree

Key Ideas

102. Binary Tree Level Order Traversal

Key Ideas

199. Binary Tree Right Side View

Key Ideas