Add details to hash tables (#178)

Author: spring1843

hashtable/README.md

@@ -1,6 +1,21 @@
 # Hash Table
 
-Hash tables are a fundamental data structure that operates based on key-value pairs and enables constant-time operations for lookup, insertion, and deletion. Hash tables use immutable keys that can be strings or integers among other things. However, in more complex applications, a hashing function, and different collision resolution methods such as separate chaining, linear probing, quadratic probing, and double hashing, can be used.
+Hash tables are a fundamental data structure that operates based on key-value pairs and enables constant-time operations for lookup, insertion, and deletion. Hash tables use immutable keys that can be strings or integers among other things. The following diagram shows a hash table that has integer keys and string values.
+
+```ASCII
+[Figure 1] Hash table with integer keys and string values
+ ┌─────┐       ┌─────┐
+ │  1  ├─────► │ foo │
+ └─────┘       └─────┘
+ ┌─────┐       ┌─────┐
+ │  2  ├─────► │ bar │
+ └─────┘       └─────┘
+ ┌─────┐       ┌─────┐
+ │  3  ├─────► │ baz │
+ └─────┘       └─────┘
+```
+
+A collision occurs if we attempt to assign "bar" at key 3 as key 3 already exists. In more complex applications to avoid key collisions, a hashing function, and different collision resolution methods such as separate chaining, linear probing, quadratic probing, and double hashing, can be used.
 
 ## Implementation
 
@@ -9,9 +24,7 @@ In Go, hash tables are implemented as maps, a built-in language data type. To de
 ```Go
 package main
 
-import (
-	"fmt"
-)
+import "fmt"
 
 func main() {
 	numbers := make(map[string]int)
@@ -33,9 +46,7 @@ As shown below it is possible in Go to store variables as keys in a map. It is a
 ```Go
 package main
 
-import (
-	"fmt"
-)
+import "fmt"
 
 type person struct {
 	name string
@@ -67,9 +78,11 @@ func isAllowed(person *person) {
 }
 ```
 
+In the above example the `struct{}` in `map[*person]struct{}` makes this map allocate no memory as value so it only contains keys. This can be useful to remove duplicates from a list or keep a list of allowed or disallowed items without spending extra memory.
+
 ## Complexity
 
-Hash tables provide O(1) time complexity for inserting, deletion, and searching operations.
+Hash tables provide O(1) time complexity for inserting, deletion, and searching operations. The space complexity of a hash table depends on what is being stored.
 
 ## Application
 

hashtable/cut_brick_wall_test.go

@@ -7,9 +7,29 @@ TestCutBrickWall tests solution(s) with the following signature and problem desc
 
 	func CutBrickWall(wall [][]int) int
 
-Given a two dimensional array of numbers representing the length of each brick in each
-row of a wall, return the position at which we could do the least amount of cuts (by not
-having to cut the touch points where bricks meet).
+Given a two dimensional array of numbers representing the length of bricks of equal hight in each
+row of a wall, return the position at which we could do the least amount of cuts in order
+to have a rectangular wall.
+
+For example given {1, 2, 2}, {3, 2}, {2, 3}, return 3.
+
+	┌─────┬───────────┬───────────┐
+	│  1  │     2     │     2     │
+	├─────┴───────────┼───────────┤
+	│        3        │     2     │
+	├───────────┬─────┴───────────┤
+	│     2     │         3       │
+	└───────────┴─────────────────┘
+
+	┌─────┬───────────┐
+	│  1  │     2     │
+	├─────┴───────────┤
+	│        3        │
+	├───────────┬─────┤
+	│     2     │  1  │
+	└───────────┴─────┘
+
+We can have the above wall after cutting only one brick at position 2 row 3.
 */
 func TestCutBrickWall(t *testing.T) {
 	tests := []struct {

hashtable/find_anagrams_test.go

@@ -10,7 +10,11 @@ TestFindAnagrams tests solution(s) with the following signature and problem desc
 
 	func FindAnagrams(words []string) [][]string
 
-Given a dictionary, return lists of words that are anagrams of each other.
+Given a dictionary, return lists of words that are anagrams of each other. Two words are
+anagrams if rearranging the letters of one results in the other.
+
+For example given {"cat", "tac", "bar", "baz", "act"} return {"cat", "tac", "act"} because they are
+the only anagrams in the list.
 */
 func TestFindAnagrams(t *testing.T) {
 	tests := []struct {

hashtable/max_points_on_line_test.go

@@ -7,8 +7,10 @@ TestMaxPointsOnALine tests solution(s) with the following signature and problem
 
 	func MaxPointsOnALine(points [][]int) int
 
-Given multiple coordinates of points like {[1,1], [2,2], [3,3], [4,5]}, return the maximum
-number of points that are on the same line like 3.
+Given multiple coordinates of points like, return the maximum number of points that are on the same.
+
+For example given {[1,1], [2,2], [3,3], [4,5]} return 3 because the points [1,1], [2,2], [3,3] are on
+the same line.
 */
 func TestMaxPointsOnALine(t *testing.T) {
 	tests := []struct {

hashtable/missing_number_test.go

@@ -7,7 +7,9 @@ TestMissingNumber tests solution(s) with the following signature and problem des
 
 	func MissingNumber(numbers []int) int
 
-Given an unsorted array of numbers like {7,5,3,4,1,2,0,-1} return the missing integer like 6.
+Given an unsorted slice of numbers like return the missing integer.
+
+For example given {7,5,3,4,1,2,0,-1}, return the missing integer like 6.
 */
 func TestMissingNumber(t *testing.T) {
 	tests := []struct {

hashtable/smallest_missing_positive_integer_test.go

@@ -7,7 +7,10 @@ TestSmallestMissingPositiveInteger tests solution(s) with the following signatur
 
 	func SmallestMissingPositiveInteger(input []int) int
 
-Given a list of integers, return the smallest missing positive integer.
+Given a slice of integers, return the smallest missing positive integer.
+
+For example given {-9, 0, 1, 2, 3, 4, 5, 6} return 7 because -9 is not a positive integer and
+all numbers from 0 to 6 are present in the list.
 */
 func TestSmallestMissingPositiveInteger(t *testing.T) {
 	tests := []struct {

hashtable/sum_up_to_k_test.go

@@ -10,7 +10,9 @@ TestSumUpToK tests solution(s) with the following signature and problem descript
 
 	func SumUpToK(numbers []int, k int) []int
 
-Given a list, output the indices of the first two elements that sum up to K.
+Given a slice of integers, output the indices of the first two elements that sum up to K.
+
+For example given {1, 2, 3, 4} and K = 5, return {1, 2} because 2 + 3 = 5.
 */
 func TestSumUpToK(t *testing.T) {
 	tests := []struct {