Fixed PR notes

Signed-off-by: Slava Lysunkin <lysunkin@gmail.com>

Author: lysunkin

go/Two Pointers/is_palindrome_valid.go

@@ -1,27 +1,23 @@
-package main
-
-import (
-	"fmt"
-	"strings"
-	"unicode"
-)
-
 func isAlnum(r rune) bool {
 	return unicode.IsLetter(r) || unicode.IsDigit(r)
 }
 
 func isPalindromeValid(input string) bool {
-	s := []rune(strings.ToLower(input))
+	s := []rune(input)
+
 	left, right := 0, len(s)-1
 
 	for left < right {
-		for !isAlnum(s[left]) && left < right {
+		// Skip non-alphanumeric characters from the left.
+		for left < right && !isAlnum(s[left]) {
 			left++
 		}
-		for !isAlnum(s[right]) && left < right {
+		// Skip non-alphanumeric characters from the right.
+		for left < right && !isAlnum(s[right]) {
 			right--
 		}
-
+		// If the characters at the left and right pointers don't
+		// match, the string is not a palindrome.
 		if s[left] != s[right] {
 			return false
 		}
@@ -32,8 +28,3 @@ func isPalindromeValid(input string) bool {
 
 	return true
 }
-
-func main() {
-	fmt.Println(isPalindromeValid("A dog! A panic in a pagoda.")) // -> true
-	fmt.Println(isPalindromeValid("abc123"))                      // -> false
-}

go/Two Pointers/largest_container.go

@@ -1,34 +1,24 @@
-package main
-
-import (
-	"fmt"
-)
-
 func largestContainer(heights []int) int {
+	maxWater := 0
 	left, right := 0, len(heights)-1
-	maxVol := 0
 
 	for left < right {
-		width := right - left
-		height := heights[left]
-		if heights[right] < height {
-			height = heights[right]
-		}
-		currentVol := width * height
-		if currentVol > maxVol {
-			maxVol = currentVol
-		}
-
+		// Calculate the water contained between the current pair of
+		// lines.
+		water := min(heights[left], heights[right]) * (right - left)
+		maxWater = max(maxWater, water)
+		// Move the pointers inward, always moving the pointer at the
+		// shorter line. If both lines have the same height, move both
+		// pointers inward.
 		if heights[left] < heights[right] {
 			left++
+		} else if heights[left] > heights[right] {
+			right--
 		} else {
+			left++
 			right--
 		}
 	}
 
-	return maxVol
-}
-
-func main() {
-	fmt.Println(largestContainer([]int{2, 7, 8, 3, 7, 6})) // -> 24
+	return maxWater
 }

go/Two Pointers/next_lexicographical_sequence.go

@@ -1,9 +1,3 @@
-package main
-
-import (
-	"fmt"
-)
-
 func reverse(s []rune, start int) {
 	end := len(s) - 1
 	for start < end {
@@ -15,31 +9,27 @@ func reverse(s []rune, start int) {
 
 func nextLexicographicalSequence(s string) string {
 	letters := []rune(s)
-	n := len(letters)
-	pivot := n - 2
-
+	// Locate the pivot, which is the first character from the right that breaks
+	// non-increasing order. Start searching from the second-to-last position.
+	pivot := len(letters) - 2
 	for pivot >= 0 && letters[pivot] >= letters[pivot+1] {
 		pivot--
 	}
-
+	// If pivot is not found, the string is already in its largest permutation. In
+	// this case, reverse the string to obtain the smallest permutation.
 	if pivot == -1 {
 		reverse(letters, 0)
 		return string(letters)
 	}
-
-	successor := n - 1
-	for letters[successor] <= letters[pivot] {
-		successor--
+	// Find the rightmost successor to the pivot.
+	rightmostSuccessor := len(letters) - 1
+	for letters[rightmostSuccessor] <= letters[pivot] {
+		rightmostSuccessor--
 	}
-
-	letters[pivot], letters[successor] = letters[successor], letters[pivot]
-
+	// Swap the rightmost successor with the pivot to increase the lexicographical
+	// order of the suffix.
+	letters[pivot], letters[rightmostSuccessor] = letters[rightmostSuccessor], letters[pivot]
+	// Reverse the suffix after the pivot to minimize its permutation.
 	reverse(letters, pivot+1)
-
 	return string(letters)
 }
-
-func main() {
-	fmt.Println(nextLexicographicalSequence("abcd")) // -> abdc
-	fmt.Println(nextLexicographicalSequence("dcba")) // -> abcd
-}

go/Two Pointers/pair_sum_sorted.go

@@ -1,24 +1,19 @@
-package main
-
-import "fmt"
-
 func pairSumSorted(nums []int, target int) []int {
 	left, right := 0, len(nums)-1
 	for left < right {
 		sum := nums[left] + nums[right]
-		if sum == target {
-			return []int{left, right}
-		}
+		// If the sum is smaller, increment the left pointer, aiming
+		// to increase the sum toward the target value.
 		if sum < target {
 			left++
-		} else {
+		} else if sum > target {
+			// If the sum is larger, decrement the right pointer, aiming
+			// to decrease the sum toward the target value.
 			right--
+		} else {
+			// If the target pair is found, return its indexes.
+			return []int{left, right}
 		}
 	}
 	return []int{}
 }
-
-func main() {
-	fmt.Println(pairSumSorted([]int{-5, -2, 3, 4, 6}, 7)) // -> [2 3]
-	fmt.Println(pairSumSorted([]int{1, 1, 1}, 2))         // -> [0 2]
-}

go/Two Pointers/shift_zeros_to_the_end.go

@@ -1,19 +1,14 @@
-package main
-
-import "fmt"
-
 func shiftZerosToTheEnd(nums []int) {
+	// The 'left' pointer is used to position non-zero elements.
 	left := 0
+	// Iterate through the array using a 'right' pointer to locate non-zero
+	// elements.
 	for right := 0; right < len(nums); right++ {
 		if nums[right] != 0 {
 			nums[left], nums[right] = nums[right], nums[left]
+			// Increment 'left' since it now points to a position already occupied
+			// by a non-zero element.
 			left++
 		}
 	}
 }
-
-func main() {
-	nums := []int{0, 1, 0, 3, 2}
-	shiftZerosToTheEnd(nums)
-	fmt.Println(nums) // -> [1 3 2 0 0]
-}

go/Two Pointers/triplet_sum.go

@@ -1,45 +1,50 @@
-package main
-
-import (
-	"fmt"
-	"sort"
-)
-
 func tripletSum(nums []int) [][]int {
-	result := [][]int{}
-
+	triplets := [][]int{}
 	sort.Ints(nums)
-	n := len(nums)
 
-	for i := 0; i < n-2; i++ {
+	for i := 0; i < len(nums); i++ {
+		// Optimization: triplets consisting of only positive numbers
+		// will never sum to 0.
+
+		if nums[i] > 0 {
+			break
+		}
+
+		// To avoid duplicate triplets, skip 'a' if it's the same as
+		// the previous number.
 		if i > 0 && nums[i] == nums[i-1] {
 			continue
 		}
 
-		left, right := i+1, n-1
-		for left < right {
-			sum := nums[i] + nums[left] + nums[right]
-			if sum == 0 {
-				result = append(result, []int{nums[i], nums[left], nums[right]})
-				left++
-				right--
-				for left < right && nums[left] == nums[left-1] {
-					left++
-				}
-				for left < right && nums[right] == nums[right+1] {
-					right--
-				}
-			} else if sum < 0 {
-				left++
-			} else {
-				right--
-			}
+		// Find all pairs that sum to a target of '-a' (-nums[i]).
+		pairs := pairSumSortedAllPairs(nums, i+1, -nums[i])
+		for _, pair := range pairs {
+			triplets = append(triplets, []int{nums[i], pair[0], pair[1]})
 		}
 	}
 
-	return result
+	return triplets
 }
 
-func main() {
-	fmt.Println(tripletSum([]int{0, -1, 2, -3, 1})) // -> [[-3 1 2] [-1 0 1]]
+func pairSumSortedAllPairs(nums []int, start int, target int) [][]int {
+	pairs := [][]int{}
+	left, right := start, len(nums)-1
+	for left < right {
+		sum := nums[left] + nums[right]
+		if sum == target {
+			pairs = append(pairs, []int{nums[left], nums[right]})
+			left++
+			// To avoid duplicate '[b, c]' pairs, skip 'b' if it's the
+			// same as the previous number.
+			for left < right && nums[left] == nums[left-1] {
+				left++
+			}
+		} else if sum < target {
+			left++
+		} else {
+			right--
+		}
+	}
+
+	return pairs
 }