[Arrays & Hashing][Group Anagrams] - Implement solution for Leetcode 49 (#9)

Author: javydevx

1_arrays_and_hashing/3_two_sum/solution.go

@@ -22,7 +22,7 @@ type Pair struct {
 
 // Time complexity: O(n log n)
 // Space complexity: O(n)
-func TwoSumSorted(nums []int, target int) []int {
+func TwoSumSort(nums []int, target int) []int {
 	pairs := make([]Pair, len(nums))
 	for i, v := range nums {
 		pairs[i] = Pair{val: v, idx: i}

1_arrays_and_hashing/3_two_sum/solution_test.go

@@ -22,12 +22,12 @@ func TestTwoSum(t *testing.T) {
 		{"Brute - Duplicates", TwoSumBruteForce, []int{3, 3}, 6, []int{0, 1}},
 
 		// Sorting (Two Pointer)
-		{"Sorted - Valid Pair", TwoSumSorted, []int{2, 7, 11, 15}, 9, []int{0, 1}},
-		{"Sorted - No Pair", TwoSumSorted, []int{1, 2, 3}, 7, nil},
-		{"Sorted - Empty", TwoSumSorted, []int{}, 0, nil},
-		{"Sorted - Single Element", TwoSumSorted, []int{5}, 5, nil},
-		{"Sorted - Negative Numbers", TwoSumSorted, []int{-3, 4, 3, 90}, 0, []int{0, 2}},
-		{"Sorted - Duplicates", TwoSumSorted, []int{3, 3}, 6, []int{0, 1}},
+		{"Sort - Valid Pair", TwoSumSort, []int{2, 7, 11, 15}, 9, []int{0, 1}},
+		{"Sort - No Pair", TwoSumSort, []int{1, 2, 3}, 7, nil},
+		{"Sort - Empty", TwoSumSort, []int{}, 0, nil},
+		{"Sort - Single Element", TwoSumSort, []int{5}, 5, nil},
+		{"Sort - Negative Numbers", TwoSumSort, []int{-3, 4, 3, 90}, 0, []int{0, 2}},
+		{"Sort - Duplicates", TwoSumSort, []int{3, 3}, 6, []int{0, 1}},
 
 		// Map Two-Pass
 		{"MapTwoPass - Valid Pair", TwoSumMapTwoPass, []int{2, 7, 11, 15}, 9, []int{0, 1}},

1_arrays_and_hashing/4_group_anagrams/solution.go

@@ -0,0 +1,66 @@
+package groupanagrams
+
+import (
+	"sort"
+	"strings"
+)
+
+// Time complexity: O(n * k log k), where n is the number of strings and k is the maximum length of a string.
+// Space complexity: O(n * k)
+func GroupAnagramsSort(strs []string) [][]string {
+	if len(strs) == 0 {
+		return [][]string{}
+	}
+
+	anagramMap := make(map[string][]string)
+
+	// for _, str := range strs {
+	// 	// Convert to a slice of runes to sort
+	// 	runes := []rune(str)
+	// 	sort.Slice(runes, func(i, j int) bool {
+	// 		return runes[i] < runes[j]
+	// 	})
+	// 	key := string(runes)
+	// 	anagramMap[key] = append(anagramMap[key], str)
+	// }
+
+	for _, str := range strs {
+		sChars := strings.Split(str, "")
+		sort.Strings(sChars)
+		sortedStr := strings.Join(sChars, "")
+
+		anagramMap[sortedStr] = append(anagramMap[sortedStr], str)
+	}
+
+	result := make([][]string, 0, len(anagramMap)) // result := [][]string{}
+	for _, group := range anagramMap {
+		result = append(result, group)
+	}
+	return result
+}
+
+// Time complexity: O(n * k)
+// Space complexity: O(n * k)
+func GroupAnagramsCount(strs []string) [][]string {
+	if len(strs) == 0 {
+		return [][]string{}
+	}
+
+	anagramMap := make(map[[26]int][]string)
+
+	for _, str := range strs {
+		var key [26]int
+		for _, char := range str {
+			if char >= 'a' && char <= 'z' {
+				key[char-'a']++
+			}
+		}
+		anagramMap[key] = append(anagramMap[key], str)
+	}
+
+	result := make([][]string, 0, len(anagramMap))
+	for _, group := range anagramMap {
+		result = append(result, group)
+	}
+	return result
+}

1_arrays_and_hashing/4_group_anagrams/solution_test.go

@@ -0,0 +1,51 @@
+package groupanagrams
+
+import (
+	"reflect"
+	"sort"
+	"strings"
+	"testing"
+)
+
+func sortGroups(groups [][]string) [][]string {
+	for _, group := range groups {
+		sort.Strings(group)
+	}
+	sort.Slice(groups, func(i, j int) bool {
+		return strings.Join(groups[i], "") < strings.Join(groups[j], "")
+	})
+	return groups
+}
+
+func TestGroupAnagrams(t *testing.T) {
+	cases := []struct {
+		name     string
+		fn       func([]string) [][]string
+		strs     []string
+		expected [][]string
+	}{
+		// GroupAnagramsSort
+		{"Sort - Basic", GroupAnagramsSort, []string{"eat", "tea", "tan", "ate", "nat", "bat"}, [][]string{{"eat", "tea", "ate"}, {"tan", "nat"}, {"bat"}}},
+		{"Sort - Empty", GroupAnagramsSort, []string{}, [][]string{}},
+		{"Sort - Single Word", GroupAnagramsSort, []string{"abc"}, [][]string{{"abc"}}},
+		{"Sort - All Same", GroupAnagramsSort, []string{"a", "a", "a"}, [][]string{{"a", "a", "a"}}},
+		{"Sort - No Anagrams", GroupAnagramsSort, []string{"a", "b", "c"}, [][]string{{"a"}, {"b"}, {"c"}}},
+
+		// GroupAnagramsCount
+		{"Count - Basic", GroupAnagramsCount, []string{"eat", "tea", "tan", "ate", "nat", "bat"}, [][]string{{"eat", "tea", "ate"}, {"tan", "nat"}, {"bat"}}},
+		{"Count - Empty", GroupAnagramsCount, []string{}, [][]string{}},
+		{"Count - Single Word", GroupAnagramsCount, []string{"abc"}, [][]string{{"abc"}}},
+		{"Count - All Same", GroupAnagramsCount, []string{"a", "a", "a"}, [][]string{{"a", "a", "a"}}},
+		{"Count - No Anagrams", GroupAnagramsCount, []string{"a", "b", "c"}, [][]string{{"a"}, {"b"}, {"c"}}},
+	}
+
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			got := sortGroups(c.fn(c.strs))
+			want := sortGroups(c.expected)
+			if !reflect.DeepEqual(got, want) {
+				t.Errorf("%s failed: expected %v, got %v", c.name, want, got)
+			}
+		})
+	}
+}