Add the maze problem (#112)

Author: spring1843

README.md

@@ -85,24 +85,25 @@ Welcome to **Data Structures and Algorithms in Go**! 🎉 This project is design
         * [Exponentiation](./recursion/exponentiation_test.go)
         * [Regular Expressions Matching](./recursion/regular_expressions_test.go)
         * [Expression Operators](./recursion/expression_operators_test.go)
-    * [Divide and Conquer](./dnc//README.md)
+    * [Divide and Conquer](./dnc/README.md)
         * [Binary Search](./dnc/binary_search_test.go)
         * [Square Root with Binary Search](./dnc/square_root_test.go)
         * [Rate Limit](./dnc/rate_limit_test.go)
         * [Towers of Hanoi](./dnc/towers_of_hanoi_test.go)
         * [Merge Sort](./dnc/merge_sort_test.go)
         * [Quick Sort](./dnc/quick_sort_test.go)
-    * [Bit Manipulation](./bit//README.md)
+    * [Bit Manipulation](./bit/README.md)
         * [Division without multiplication or division operators](./bit/division_without_operators_test.go)
         * [Middle without division](./bit/middle_without_division_test.go)
         * [Addition without using plus (+) or any other arithmetic operators](./bit/addition_without_operators_test.go)
         * [Power of Two](./bit/is_power_of_two_test.go)
         * [Maximum without if conditions](./bit/max_function_without_conditions_test.go)
         * [Oddly Repeated Number](./bit/oddly_repeated_number_test.go)
-    * [Backtracking](./backtracking//README.md)
+    * [Backtracking](./backtracking/README.md)
         * [Permutations](./backtracking/permutations_test.go)
         * [Generate Parentheses](./backtracking/generate_parentheses_test.go)
         * [Phone Letter Combinations](./backtracking/phone_letter_combinations_test.go)
+        * [Maze](./backtracking/maze_test.go),
         * [Sudoku](./backtracking/sudoku_test.go)
         * [N Queens](./backtracking/n_queens_test.go)
     * [Graphs](./graph/README.md)

backtracking/README.md

@@ -25,8 +25,9 @@ Backtracking is widely used to solve board games and computers use it to select
 
 ## Permutations
 
-* [Permutations](permutations_test.go),  [Solution](permutations.go)
-* [Generate Parentheses](./generate_parentheses_test.go), [Solution](generate_parentheses.go)
-* [Phone Letter Combinations](phone_letter_combinations_test.go), [Solution](phone_letter_combinations.go)
-* [Sudoku](sudoku_test.go), [Solution](sudoku.go)
-* [N Queens](n_queens_test.go), [Solution](n_queens.go)
+* [Permutations](./permutations_test.go),  [Solution](./permutations.go)
+* [Generate Parentheses](./generate_parentheses_test.go), [Solution](./generate_parentheses.go)
+* [Phone Letter Combinations](./phone_letter_combinations_test.go), [Solution](./phone_letter_combinations.go)
+* [Maze](./maze_test.go), [Solution](./maze.go)
+* [Sudoku](./sudoku_test.go), [Solution](./sudoku.go)
+* [N Queens](./n_queens_test.go), [Solution](./n_queens.go)

backtracking/maze.go

@@ -0,0 +1,38 @@
+package backtracking
+
+var (
+	directions      = [4][2]int{{0, 1}, {0, -1}, {1, 0}, {-1, 0}}
+	directionLetter = map[int]string{0: "r", 1: "l", 2: "d", 3: "u"}
+)
+
+// Maze solves the problem in O(mn) time and O(mn) space complexity.
+func Maze(m, n int, walls [][2]int, start, finish [2]int) string {
+	wallMap := make(map[[2]int]bool)
+	for _, wall := range walls {
+		wallMap[wall] = true
+	}
+
+	visited := make([][]bool, m)
+	for i := range visited {
+		visited[i] = make([]bool, n)
+	}
+
+	return mazeRecursive(start[0], start[1], "", wallMap, visited, finish)
+}
+
+func mazeRecursive(x, y int, path string, wallMap map[[2]int]bool, visited [][]bool, finish [2]int) string {
+	if x == finish[0] && y == finish[1] {
+		return path
+	}
+
+	visited[x][y] = true
+	for i := 0; i < 4; i++ {
+		nx, ny := x+directions[i][0], y+directions[i][1]
+		if nx >= 0 && nx < len(visited) && ny >= 0 && ny < len(visited[0]) && !visited[nx][ny] && !wallMap[[2]int{nx, ny}] {
+			if result := mazeRecursive(nx, ny, path+directionLetter[i], wallMap, visited, finish); result != "" {
+				return result
+			}
+		}
+	}
+	return ""
+}

backtracking/maze_test.go

@@ -0,0 +1,46 @@
+package backtracking
+
+import (
+	"reflect"
+	"testing"
+)
+
+/*
+TestMaze tests solution(s) with the following signature and problem description:
+
+	func Maze(walls [][2]int, start, finish [2]int,m,n int) string
+
+Given the coordinates of walls in a m x n maze in tuples of {row, col} format, and start
+and finish coordinates in the same format, find a path from start to finish. return
+a string of directions like `lrud` (left, right, up, down) to get a robot from
+start to finish.
+
+The robot can only move in the four left, right, down and up directions and not
+through walls. The robot does not know where the finish line is so it has to
+explore every possible cell in the order of directions given.
+*/
+func TestMaze(t *testing.T) {
+	tests := []struct {
+		m      int
+		n      int
+		walls  [][2]int
+		start  [2]int
+		finish [2]int
+		moves  string
+	}{
+		{1, 1, [][2]int{}, [2]int{0, 0}, [2]int{0, 1}, ""},
+		{5, 5, [][2]int{}, [2]int{0, 0}, [2]int{0, 1}, "r"},
+		{10, 10, [][2]int{}, [2]int{0, 0}, [2]int{0, 1}, "r"},
+		{5, 5, [][2]int{}, [2]int{0, 0}, [2]int{4, 4}, "rrrrdlllldrrrrdlllldrrrr"},
+		{5, 5, [][2]int{{1, 1}, {1, 2}, {1, 3}, {2, 3}, {3, 3}, {3, 4}}, [2]int{0, 0}, [2]int{2, 4}, "rrrrdd"},
+		{5, 5, [][2]int{{0, 0}, {0, 1}, {0, 2}, {0, 3}, {1, 3}, {2, 1}, {2, 2}, {2, 3}, {3, 1}, {4, 1}}, [2]int{4, 0}, [2]int{1, 2}, "uuurr"},
+		{5, 5, [][2]int{{1, 0}, {1, 1}, {1, 2}, {1, 3}, {3, 1}, {3, 2}, {3, 3}, {3, 4}}, [2]int{0, 0}, [2]int{4, 4}, "rrrrddllllddrrrr"},
+		{5, 5, [][2]int{{1, 0}, {1, 1}, {1, 4}, {1, 3}, {3, 1}, {3, 2}, {3, 3}, {3, 4}}, [2]int{0, 0}, [2]int{4, 4}, "rrddllddrrrr"},
+	}
+
+	for i, test := range tests {
+		if got := Maze(test.m, test.n, test.walls, test.start, test.finish); !reflect.DeepEqual(test.moves, got) {
+			t.Fatalf("Failed test case #%d. Want %s got %s", i, test.moves, got)
+		}
+	}
+}

heap/README.md

@@ -7,7 +7,7 @@ A heap must satisfy two conditions:
 1. The structure property requires that the heap be a complete binary search [tree](../tree), where each level is filled from left to right, and all levels except the bottom are full.
 2. The heap property requires that the children of a node be larger than or equal to the parent node in a min heap and smaller than or equal to the parent in a max heap, meaning that the root is the minimum in a min heap and the maximum in a max heap.
 
-As a result, if all elements are pushed to the min or max heap and then popped one by one, a sorted list in ascending or descending order is attained. This sorting technique known as [heap sort](./heap_sort_test.go) works in O(n*Logn) time. While other sorting algorithms are available, none are more efficient than O(n*Log n).
+As a result, if all elements are pushed to the min or max heap and then popped one by one, a sorted list in ascending or descending order is attained. This sorting technique known as [heap sort](./heap_sort_test.go) works in O(n*Logn) time. While other comparison based sorting algorithms are available, none can be more efficient than O(n*Log n).
 
 When pushing an element to a heap, because of the structure property, the new element is always added to the first available position on the lowest level of the heap, filling from left to right. Then to maintain the heap property, if the newly inserted element is smaller than its parent in a min heap (larger in a max heap), the newly added element is percolated up by being swapped with its parent. The child and parents are swapped until the heap property is achieved.
 

recursion/expression_operators.go

@@ -16,13 +16,11 @@ func expressionOperatorsHelper(list []int, current int, operators string, target
 		return ""
 	}
 
-	// Try with the + operator
 	result := expressionOperatorsHelper(list[1:], current+list[0], operators+"+", target)
 	if result != "" {
 		return result
 	}
 
-	// Try with the - operator
 	result = expressionOperatorsHelper(list[1:], current-list[0], operators+"-", target)
 	if result != "" {
 		return result