Go: Chapter 2 Hash Maps and Sets

Author: ineBallardin

go/Hash Maps and Sets/geometric_sequence_triplets.go

@@ -0,0 +1 @@
+package hashmapsandsets

go/Hash Maps and Sets/longest_chain_of_consecutive_numbers.go

@@ -0,0 +1,29 @@
+package hashmapsandsets
+
+func LongestChainOfConsecutiveNumbers(nums []int) int {
+	if len(nums) == 0 {
+		return 0
+	}
+	numSet := make(map[int]bool)
+	for _, num := range nums {
+		numSet[num] = true
+	}
+	longestChain := 0
+	for num := range numSet {
+		// If the current number is the smallest number in its chain, search for
+		// the length of its chain.
+		if !numSet[num-1] {
+			currentNum := num
+			currentChain := 1
+			// Continue to find the next consecutive numbers in the chain.
+			for numSet[currentNum+1] {
+				currentNum++
+				currentChain++
+			}
+			if currentChain > longestChain {
+				longestChain = currentChain
+			}
+		}
+	}
+	return longestChain
+}

go/Hash Maps and Sets/longest_chain_of_consecutive_numbers_brute_force.go

@@ -0,0 +1,33 @@
+package hashmapsandsets
+
+func LongestChainOfConsecutiveNumbersBruteForce(nums []int) int {
+	if len(nums) == 0 {
+		return 0
+	}
+	longestChain := 0
+	// Look for chains of consecutive numbers that start from each number.
+	for _, num := range nums {
+		currentNum := num
+		currentChain := 1
+		// Continue to find the next consecutive numbers in the chain.
+		for contains(nums, currentNum+1) {
+			currentNum++
+			currentChain++
+		}
+		if currentChain > longestChain {
+			longestChain = currentChain
+		}
+	}
+	return longestChain
+}
+
+// In the Python code, the while loop checks (current_num +1) in nums.
+// So the helper function 'contains' is needed.
+func contains(nums []int, target int) bool {
+	for _, n := range nums {
+		if n == target {
+			return true
+		}
+	}
+	return false
+}

go/Hash Maps and Sets/pair_sum_unsorted.go

@@ -0,0 +1,13 @@
+package hashmapsandsets
+
+func PairSumUnsorted(nums []int, target int) []int {
+	hashmap := make(map[int]int)
+	for i, x := range nums {
+		complement := target - x
+		if idx, exists := hashmap[complement]; exists {
+			return []int{idx, i}
+		}
+		hashmap[x] = i
+	}
+	return nil
+}

go/Hash Maps and Sets/pair_sum_unsorted_two_pass.go

@@ -0,0 +1,17 @@
+package hashmapsandsets
+
+func PairSumUnsortedTwoPass(nums []int, target int) []int {
+	numMap := make(map[int]int)
+	// First pass: Populate the hash map with each number and its index.
+	for i, num := range nums {
+		numMap[num] = i
+	}
+	// Second pass: Check for each number's complement in the hash map.
+	for i, num := range nums {
+		complement := target - num
+		if idx, ok := numMap[complement]; ok && idx != i {
+			return []int{i, idx}
+		}
+	}
+	return nil
+}

go/Hash Maps and Sets/verify_sudoku_board.go

@@ -0,0 +1,49 @@
+package hashmapsandsets
+
+func VerifySudokuBoard(board [][]int) bool {
+	// Create hash sets for each row, column, and subgrid to keep
+	// track of numbers previously seen on any given row, column, or
+	// subgrid.
+	rowSets := make([]map[int]struct{}, 9)
+	columnSets := make([]map[int]struct{}, 9)
+	subgridSets := make([][]map[int]struct{}, 3)
+
+	for i := range rowSets {
+		rowSets[i] = make(map[int]struct{})
+	}
+	for i := range columnSets {
+		columnSets[i] = make(map[int]struct{})
+	}
+	for i := range subgridSets {
+		subgridSets[i] = make([]map[int]struct{}, 3)
+		for j := range subgridSets[i] {
+			subgridSets[i][j] = make(map[int]struct{})
+		}
+	}
+
+	for r := 0; r < 9; r++ {
+		for c := 0; c < 9; c++ {
+			num := board[r][c]
+			if num == 0 {
+				continue
+			}
+			// Check if 'num' has been seen in the current row,
+			// column, or subgrid.
+			if _, exists := rowSets[r][num]; exists {
+				return false
+			}
+			if _, exists := columnSets[c][num]; exists {
+				return false
+			}
+			if _, exists := subgridSets[r/3][c/3][num]; exists {
+				return false
+			}
+			// If we passed the above checks, mark this value as seen
+			// by adding it to its corresponding hash sets.
+			rowSets[r][num] = struct{}{}
+			columnSets[c][num] = struct{}{}
+			subgridSets[r/3][c/3][num] = struct{}{}
+		}
+	}
+	return true
+}

go/Hash Maps and Sets/zero_striping.go

@@ -0,0 +1,58 @@
+package hashmapsandsets
+
+func ZeroStriping(matrix [][]int) {
+	if len(matrix) == 0 || len(matrix[0]) == 0 {
+		return
+	}
+	m, n := len(matrix), len(matrix[0])
+	// Check if the first row initially contains a zero.
+	firstRowHasZero := false
+	for c := 0; c < n; c++ {
+		if matrix[0][c] == 0 {
+			firstRowHasZero = true
+			break
+		}
+	}
+	// Check if the first column initially contains a zero.
+	firstColHasZero := false
+	for r := 0; r < m; r++ {
+		if matrix[r][0] == 0 {
+			firstColHasZero = true
+			break
+		}
+	}
+	// Use the first row and column as markers. If an element in the
+	// submatrix is zero, mark its corresponding row and column in the
+	// first row and column as 0.
+	for r := 1; r < m; r++ {
+		for c := 1; c < n; c++ {
+			if matrix[r][c] == 0 {
+				matrix[0][c] = 0
+				matrix[r][0] = 0
+			}
+		}
+	}
+	// Update the submatrix using the markers in the first row and
+	// column.
+	for r := 1; r < m; r++ {
+		for c := 1; c < n; c++ {
+			if matrix[0][c] == 0 || matrix[r][0] == 0 {
+				matrix[r][c] = 0
+			}
+		}
+	}
+	// If the first row had a zero initially, set all elements in the
+	// first row to zero.
+	if firstRowHasZero {
+		for c := 0; c < n; c++ {
+			matrix[0][c] = 0
+		}
+	}
+	// If the first column had a zero initially, set all elements in
+	// the first column to zero.
+	if firstColHasZero {
+		for r := 0; r < m; r++ {
+			matrix[r][0] = 0
+		}
+	}
+}

go/Hash Maps and Sets/zero_striping_hash_sets.go

@@ -0,0 +1,32 @@
+package hashmapsandsets
+
+func ZeroStripingHashSets(matrix [][]int) {
+	if len(matrix) == 0 || len(matrix[0]) == 0 {
+		return
+	}
+	m, n := len(matrix), len(matrix[0])
+	zeroRows := make(map[int]struct{})
+	zeroCols := make(map[int]struct{})
+	// Pass 1: Traverse through the matrix to identify the rows and
+	// columns containing zeros and store their indexes in the
+	// appropriate hash sets.
+	for r := 0; r < m; r++ {
+		for c := 0; c < n; c++ {
+			if matrix[r][c] == 0 {
+				zeroRows[r] = struct{}{}
+				zeroCols[c] = struct{}{}
+			}
+		}
+	}
+	// Pass 2: Set any cell in the matrix to zero if its row index is
+	// in 'zero_rows' or its column index is in 'zero_cols'.
+	for r := 0; r < m; r++ {
+		for c := 0; c < n; c++ {
+			if _, ok := zeroRows[r]; ok {
+				matrix[r][c] = 0
+			} else if _, ok := zeroCols[c]; ok {
+				matrix[r][c] = 0
+			}
+		}
+	}
+}