Algorithms on maladroit.dev

Algorithms

Mon, 01 Jan 0001 00:00:00 +0000

Algorithms

Algorithms are step by step procedures that are used for solving a computational problem. An algorithm is different from a program in that algorithms are used during the Software-design-phase. An algorithm should be independent of programming languages and are analyzed for performance. In order to design an algorithm, a designer must have domain knowledge of the problem that they are attempting to solve.

Binary search

Mon, 01 Jan 0001 00:00:00 +0000

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.

Method

Iterate over array and change the start/end to be the mid point

Solution

go

func search(nums []int, target int) int {
	start, end := 0, len(nums) - 1
	var mid int
	for start <= end {
		mid = (end + start) / 2
		if nums[mid] < target {
			start = mid + 1
		} else if nums[mid] > target {
			end = mid - 1
		} else {
			return mid
		}
	}
	return -1
}

References

Breadth first search

Mon, 01 Jan 0001 00:00:00 +0000

Breadth first search

Breadth-first search is a graph traversal algorithm that starts at a node and travels to all other nodes at the current depth before moving further into the graph. queue are a good data structure for tracking of the nodes that have been encountered, but not traversed.

ℹ️ Note

It is important to use a double-ended queue (not an array) due to the time complexity of dequeuing.

Implementations

go

var (
	directions = [][]int{
 {0, 1}, {0, -1}, {1, 0}, {-1, 0}
 }
)

type graph struct {
	nodes [][]int
	rows int
	cols int
}

func NewGraph(x, y int) *graph {
	g := &graph{
		nodes: make([][]int, x),
		rows: x,
		cols: y,
	}
	for i := range g.nodes {
		g.nodes[i] = make([]int, y)
	}
	return g
}

func (g *graph) bfs(startX, startY int) {
	if len(g.nodes) <= 0 {
		return
	}
	visited := make([][]bool, g.rows)
	for i := range visited {
		visited[i] = make([]bool, g.cols)
	}

	queue := [][2]int{}
	g.bfsTraverse(startX, startY, visited, queue)
}

func (g *graph) bfsTraverse(
	x, y int,
	visited [][]bool,
	queue [][2]int,
) {
	queue = append(queue, [2]int{x, y})
	for len(queue) > 0 {
		i, j := queue[0][0], queue[0][1]
		queue = queue[1:]
		if visited[i][j] == true {
			continue
		}
		visited[i][j] = true
		fmt.Printf("visited: %v, %v\n", i, j)
		for _, direction := range directions {
			nextI, nextJ := i+direction[0], j+direction[1]
			if nextI < 0 || nextI >= g.rows {
				continue
			}
			if nextJ < 0 || nextJ >= g.cols {
				continue
			}
			queue = append(queue, [2]int{nextI, nextJ})
		}
	}
}

References

Constant time functions

Mon, 01 Jan 0001 00:00:00 +0000

Constant time functions

$$f(n)=1$$

Constant functions are the fastest function classes when describing an algorithm

References

The Algorithm Design Manual

Cubic Time Functions

Mon, 01 Jan 0001 00:00:00 +0000

Cubic time functions

f(n)=n^3

Cubic functions describe algorithms that examine all triples

References

The-Algorithm-Design-Manual

Depth first search

Mon, 01 Jan 0001 00:00:00 +0000

Depth-first-search

Depth first search is a graph traversal algorithm that travels as far as possible along edges before it backtracks. This is typically accomplished using a Stack to keep track of the nodes on the current path. This could be an implicit stack through using recursion or a literal stack data structure.

Example

go

var (
	directions = [][]int{
 {0, 1}, {0, -1}, {1, 0}, {-1, 0}
 }
)

type graph struct {
	nodes [][]int
	rows int
	cols int
}

func NewGraph(x, y int) *graph {
	g := &graph{
		nodes: make([][]int, x),
		rows: x,
		cols: y,
	}
	for i := range g.nodes {
		g.nodes[i] = make([]int, y)
	}
	return g
}

func (g *graph) dfs(startX, startY int) {
	if len(g.nodes) <= 0 {
		return
	}
	visited := make([][]bool, g.rows)
	for i := range visited {
		visited[i] = make([]bool, g.cols)
	}
	g.dfsTraverse(startX, startY, visited)
}

func (g *graph) dfsTraverse(i, j int, visited [][]bool) {
	if visited[i][j] == true {
		return
	}
	visited[i][j] = true
	fmt.Printf("visited: %v, %v\n", i, j)
	for _, direction := range directions {
		nextI, nextJ := i+direction[0], j+direction[1]
		if nextI < 0 || nextI >= g.rows {
			continue
		}
		if nextJ < 0 || nextJ >= g.cols {
			continue
		}
		g.dfsTraverse(nextI, nextJ, visited)
	}
}

References

Exponential time functions

Mon, 01 Jan 0001 00:00:00 +0000

Exponential time functions

f(n)=c^n

Exponential functions describe algorithms when iterating over all subsets of n items

References

The-Algorithm-Design-Manual

Factorial time functions

Mon, 01 Jan 0001 00:00:00 +0000

Factorial time functions

f(n)=n!

Factorial functions exist when generating all permutations or orderings of n items

References

The-Algorithm-Design-Manual

KMP

Mon, 01 Jan 0001 00:00:00 +0000

KMP Algorithm

Knuth-Morris-Pratt (KMP) is an algorithm for pattern matching in a string similar to the Sliding-window technique. The primary difference in KMP is that the algorithm does not backtrack on the text string and instead creates a lookup up index in the pattern string.

To accomplish this, a prefix look up table is generated where all the sub-strings in the pattern string that match the largest repeating prefix are given index values. This index value is used as a point of reference for where to backtrack in the pattern string when a match is not found. This allows pattern matching without the need to back track in the text string.

Linear time functions

Mon, 01 Jan 0001 00:00:00 +0000

Linear time functions

f(n)=n

Linear functions describe algorithms that need look at everything once such as a for loop.

References

The-Algorithm-Design-Manual

Logarithmic time functions

Mon, 01 Jan 0001 00:00:00 +0000

Logarithmic time functions

f(n)=log(n)

Logarithmic functions grow very slowly as n gets large, but not as slow as Constant-functions

References

The-Algorithm-Design-Manual

Quadratic time functions

Mon, 01 Jan 0001 00:00:00 +0000

Quadratic time functions

f(n)=n^2

Quadratic functions describe algorithms that require examining all pairs of elements.

References

The-Algorithm-Design-Manual

Rabin-Karp

Mon, 01 Jan 0001 00:00:00 +0000

Rabin-Karp Algorithm

The Rabin-Karp algorithm is a method of finding all occurrences of a sub-string in a given string. The naive approach to this solution would be to use the Sliding-window technique. Rabin-Karp has a similar approach, but instead of comparing the window to the sub-string, it instead compares hash values using a rolling hash function.

Complexity

It has an average/best case time complexity of O(n+m) and a worse case time complexity of O(n * m). The worst case would occur if all the calculated hash values of the text were the same as the calculated hash of the pattern. It has auxiliary complexity of O(1).

RAM Model of Computing

Mon, 01 Jan 0001 00:00:00 +0000

RAM Model of Computing

The RAM Model of Computation is a model for measuring time by counting the number of steps an algorithm must take to complete. There are some assumptions made in the RAM Model such as:

All simple operations are considered to be 1 step
Loops and subroutines count for N steps with N being the number of iterations
Memory access takes 1 step

Another crucial part of the RAM Model is analyzing algorithms in multiple scenarios. The RAM Model considers:

Sliding window

Mon, 01 Jan 0001 00:00:00 +0000

Sliding window

Sliding window is a technique that accomplishes what would normally taking multiple iterations in a single iteration. The technique can be applied when given a window of a known size, finding the result for the first window, and then shifting the window to the next position in the array or string.

Common use cases

largest sum
min/max sum
sub array/string

Examples

python

def slidingWindow(arr, windowSize):
	arrLen = len(arr)
	# outer loop needs to account for to avoid out of bounds
	for i in range(arrLen - windowSize + 1):
		# inner loop only needs to iterate over the window
		for j in range(windowSize)
			# operation inside the window
	return result

go

func slidingWindow(arr []int, windowSize int) int {
	arrLen := len(arr)
	// outer loop needs to account for to avoid out of bounds
	for i := 0; i < (arrLen - windowSize + 1); i++{
		// inner loop only needs to iterate over the window
		for j := 0; j < windowSize; j++ {
			// operation inside the window
		}
	}
	return result
}

Sorting and searching

Mon, 01 Jan 0001 00:00:00 +0000

Sorting and searching

Sorting is the act of rearranging a sequence in some known order such as numerical or lexicographical that is either ascending or descending. Sorting arrays are valuable as they enable binary searching which is faster than linear time.

Complexity

Sorting

Algorithm	Time	Space
Bubble sort	O(n^2)	O(1)
Insertion sort	O(n^2)	O(1)
Selection sort	O(n^2)	O(1)
Quicksort	O(n log(n))	O(log(n))
Mergesort	O(n log(n))	O(n)
Heapsort	O(n log(n))	O(1)
Counting sort	O(n + k)	O(k)
Radix sort	O(nk)	O(n + k)

Searching

Algorithm	Time
Binary search	O(log(n))

Edge cases

Empty sequence
Sequence with one element
Sequence with two elements
Sequence with duplicate elements

References

Tech-Interview-Handbook

Super-linear time functions

Mon, 01 Jan 0001 00:00:00 +0000

Super-linear time functions

f(n)=n*log(n)

Functions that are super-linear grow slightly faster than linear, but not by much.

References

The-Algorithm-Design-Manual

Topological sort

Mon, 01 Jan 0001 00:00:00 +0000

Topological sorting

A topological sort is a linear ordering of a directed graph. The ordering works similarly to Depth-first-search, but the nodes are considered “visited” when all of it’s dependencies are visited. This is an algorithm that is commonly used for discovering dependencies or prerequisites between nodes.

Examples

go

type graph struct {
	nodes []*node
}

type node struct {
	name string
	edges []*node
}

func NewGraph() *graph {
	return &graph{nodes: []*node{}}
}

func NewNode(name string) *node {
	return &node{name: name, edges: []*node{}}
}

func (g *graph) AddNode(n *node) {
	g.nodes = append(g.nodes, n)
}

func (n *node) AddEdge(e *node) {
	n.edges = append(n.edges, e)
}

func (g *graph) TopologicalSort() {
	if len(g.nodes) <= 0 {
		return
	}
	visited := map[*node]bool{}
	stack := []*node{}
	for _, node := range g.nodes {
		if visited[node] == false {
			stack = g.tsTraverse(node, visited, stack)
		}
	}
	for _, n := range stack {
		fmt.Println(n.name)
	}
}

func (g *graph) tsTraverse(
	node *node,
	visited map[*node]bool,
	stack []*node,
) []*node {
	visited[node] = true
	for _, edge := range node.edges {
		if visited[edge] == false {
			stack = g.tsTraverse(edge, visited, stack)
		}
	}
	return append(stack, node)
}

References

Traverse from right

Mon, 01 Jan 0001 00:00:00 +0000

Traverse-from-right

Occasionally it can be effect to traverse an array from right to left instead of left to right.