Merge branch 'main' into feat/sorting-exercise

Author: kawpii

internal/exercises/catalog.yaml

@@ -227,3 +227,13 @@ projects:
     - "Use Go's `time.Unix()` to convert an epoch to time."
     - "Use `t.Unix()` to convert time back to epoch."
     - "Remember Go’s `time.Parse` can help parse date strings."
+
+- slug: 37_sorting_by_functions
+  title: "Sorting by Functions"
+  difficulty: beginner
+  topics: ["slices", "sorting", "functions"]
+  hints:
+      - "Implement sort.Interface with Len(), Less(), and Swap() methods"
+      - "Create custom slice types like ByName and ByAge (e.g., type ByName []Person)"
+      - "Use sort.Sort() to sort slices with your custom comparison logic"
+      - "Remember to make copies of slices to avoid modifying the original"

internal/exercises/solutions/37_sorting_by_functions/sorting_by_functions.go

@@ -0,0 +1,65 @@
+package sorting_by_functions
+
+import "sort"
+
+// Person represents a person with a name and age
+type Person struct {
+	Name string
+	Age  int
+}
+
+// ByName is a type for sorting Person slices by name
+type ByName []Person
+
+// Implement sort.Interface for ByName
+func (b ByName) Len() int {
+	return len(b)
+}
+
+func (b ByName) Swap(i, j int) {
+	b[i], b[j] = b[j], b[i]
+}
+
+func (b ByName) Less(i, j int) bool {
+	return b[i].Name < b[j].Name
+}
+
+// ByAge is a type for sorting Person slices by age
+type ByAge []Person
+
+// Implement sort.Interface for ByAge
+func (b ByAge) Len() int {
+	return len(b)
+}
+
+func (b ByAge) Swap(i, j int) {
+	b[i], b[j] = b[j], b[i]
+}
+
+func (b ByAge) Less(i, j int) bool {
+	return b[i].Age < b[j].Age
+}
+
+// SortByName sorts a slice of Person by name using the custom ByName type
+func SortByName(people []Person) []Person {
+	// Create a copy of the slice to avoid modifying the original
+	result := make([]Person, len(people))
+	copy(result, people)
+
+	// Sort the copy by name
+	sort.Sort(ByName(result))
+
+	return result
+}
+
+// SortByAge sorts a slice of Person by age using the custom ByAge type
+func SortByAge(people []Person) []Person {
+	// Create a copy of the slice to avoid modifying the original
+	result := make([]Person, len(people))
+	copy(result, people)
+
+	// Sort the copy by age
+	sort.Sort(ByAge(result))
+
+	return result
+}

internal/exercises/templates/37_sorting_by_functions/sorting_by_functions.go

@@ -0,0 +1,63 @@
+package sorting_by_functions
+
+// import sort package
+
+// TODO:
+// - Implement the sort.Interface methods for ByName and ByAge
+// - Complete SortByName and SortByAge functions to sort slices using custom comparison
+
+// Person represents a person with a name and age
+type Person struct {
+	Name string
+	Age  int
+}
+
+// ByName is a type for sorting Person slices by name
+type ByName []Person
+
+// Implement sort.Interface for ByName
+func (b ByName) Len() int {
+	// TODO: return the length of the slice
+	return 0
+}
+
+func (b ByName) Swap(i, j int) {
+	// TODO: swap elements at positions i and j
+}
+
+func (b ByName) Less(i, j int) bool {
+	// TODO: return true if element at i should come before element at j (compare by name)
+	return false
+}
+
+// ByAge is a type for sorting Person slices by age
+type ByAge []Person
+
+// Implement sort.Interface for ByAge
+func (b ByAge) Len() int {
+	// TODO: return the length of the slice
+	return 0
+}
+
+func (b ByAge) Swap(i, j int) {
+	// TODO: swap elements at positions i and j
+}
+
+func (b ByAge) Less(i, j int) bool {
+	// TODO: return true if element at i should come before element at j (compare by age)
+	return false
+}
+
+// SortByName sorts a slice of Person by name using the custom ByName type
+func SortByName(people []Person) []Person {
+	// TODO: create a copy of the slice and sort it by name
+	// Hint: use sort.Sort() with ByName type
+	return nil
+}
+
+// SortByAge sorts a slice of Person by age using the custom ByAge type
+func SortByAge(people []Person) []Person {
+	// TODO: create a copy of the slice and sort it by age
+	// Hint: use sort.Sort() with ByAge type
+	return nil
+}

internal/exercises/templates/37_sorting_by_functions/sorting_by_functions_test.go

@@ -0,0 +1,126 @@
+package sorting_by_functions
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestSortByName(t *testing.T) {
+	people := []Person{
+		{Name: "Charlie", Age: 30},
+		{Name: "Alice", Age: 25},
+		{Name: "Bob", Age: 35},
+	}
+
+	expected := []Person{
+		{Name: "Alice", Age: 25},
+		{Name: "Bob", Age: 35},
+		{Name: "Charlie", Age: 30},
+	}
+
+	result := SortByName(people)
+	if !reflect.DeepEqual(result, expected) {
+		t.Errorf("SortByName() = %v, want %v", result, expected)
+	}
+
+	// Ensure original slice is not modified
+	originalExpected := []Person{
+		{Name: "Charlie", Age: 30},
+		{Name: "Alice", Age: 25},
+		{Name: "Bob", Age: 35},
+	}
+	if !reflect.DeepEqual(people, originalExpected) {
+		t.Errorf("Original slice was modified: %v, want %v", people, originalExpected)
+	}
+}
+
+func TestSortByAge(t *testing.T) {
+	people := []Person{
+		{Name: "Charlie", Age: 30},
+		{Name: "Alice", Age: 25},
+		{Name: "Bob", Age: 35},
+	}
+
+	expected := []Person{
+		{Name: "Alice", Age: 25},
+		{Name: "Charlie", Age: 30},
+		{Name: "Bob", Age: 35},
+	}
+
+	result := SortByAge(people)
+	if !reflect.DeepEqual(result, expected) {
+		t.Errorf("SortByAge() = %v, want %v", result, expected)
+	}
+
+	// Ensure original slice is not modified
+	originalExpected := []Person{
+		{Name: "Charlie", Age: 30},
+		{Name: "Alice", Age: 25},
+		{Name: "Bob", Age: 35},
+	}
+	if !reflect.DeepEqual(people, originalExpected) {
+		t.Errorf("Original slice was modified: %v, want %v", people, originalExpected)
+	}
+}
+
+func TestByNameInterface(t *testing.T) {
+	people := []Person{
+		{Name: "Charlie", Age: 30},
+		{Name: "Alice", Age: 25},
+		{Name: "Bob", Age: 35},
+	}
+
+	byName := ByName(people)
+
+	// Test Len
+	if byName.Len() != 3 {
+		t.Errorf("ByName.Len() = %d, want 3", byName.Len())
+	}
+
+	// Test Less
+	if !byName.Less(1, 0) { // "Alice" < "Charlie"
+		t.Errorf("ByName.Less(1, 0) should be true (Alice < Charlie)")
+	}
+	if byName.Less(0, 1) { // "Charlie" > "Alice"
+		t.Errorf("ByName.Less(0, 1) should be false (Charlie > Alice)")
+	}
+
+	// Test Swap
+	original := make([]Person, len(people))
+	copy(original, people)
+	byName.Swap(0, 1)
+	if byName[0].Name != original[1].Name || byName[1].Name != original[0].Name {
+		t.Errorf("ByName.Swap(0, 1) did not swap correctly")
+	}
+}
+
+func TestByAgeInterface(t *testing.T) {
+	people := []Person{
+		{Name: "Charlie", Age: 30},
+		{Name: "Alice", Age: 25},
+		{Name: "Bob", Age: 35},
+	}
+
+	byAge := ByAge(people)
+
+	// Test Len
+	if byAge.Len() != 3 {
+		t.Errorf("ByAge.Len() = %d, want 3", byAge.Len())
+	}
+
+	// Test Less
+	if !byAge.Less(1, 0) { // 25 < 30
+		t.Errorf("ByAge.Less(1, 0) should be true (25 < 30)")
+	}
+	if byAge.Less(0, 1) { // 30 > 25
+		t.Errorf("ByAge.Less(0, 1) should be false (30 > 25)")
+	}
+
+	// Test Swap
+	original := make([]Person, len(people))
+	copy(original, people)
+	byAge.Swap(0, 1)
+	if byAge[0].Age != original[1].Age || byAge[1].Age != original[0].Age {
+		t.Errorf("ByAge.Swap(0, 1) did not swap correctly")
+	}
+}