add: 42_wait_group exercise with template, solution, and tests (#162)

Co-authored-by: kaushalyap <24698778+kaushalyap@users.noreply.github.com>

Author: sidharth-chauhan

internal/exercises/catalog.yaml

@@ -197,6 +197,17 @@ concepts:
   hints:
     - Use `select` to handle multiple channel operations concurrently.
     - Use `time.After` to simulate a 5 microsecond timeout.
+- slug: 42_wait_group
+  title: WaitGroups
+  test_regex: ".*"
+  difficulty: beginner
+  topics: ["concurrency", "sync", "goroutines"]
+  hints:
+    - "Use sync.WaitGroup to wait for all launched goroutines."
+    - "Call wg.Add(1) before starting a goroutine and wg.Done() when it finishes."
+    - "Close result channels after wg.Wait() so collectors can range over them."
+    - "Capture loop variables correctly inside goroutines (e.g., `n := n`)."
+    - "Return results as a slice — order does not need to match input order."
 projects:
 - slug: 101_text_analyzer
   title: Text Analyzer (Easy)

internal/exercises/solutions/42_wait_group/wait_group.go

@@ -0,0 +1,33 @@
+package waitgroup
+
+import "sync"
+
+func Squares(nums []int) []int {
+	length := len(nums)
+	if length == 0 {
+		return []int{}
+	}
+
+	ch := make(chan int, length)
+	var wg sync.WaitGroup
+	wg.Add(length)
+
+	for _, n := range nums {
+		n := n
+		go func() {
+			defer wg.Done()
+			ch <- n * n
+		}()
+	}
+
+	go func() {
+		wg.Wait()
+		close(ch)
+	}()
+
+	out := make([]int, 0, length)
+	for v := range ch {
+		out = append(out, v)
+	}
+	return out
+}

internal/exercises/templates/42_wait_group/wait_group.go

@@ -0,0 +1,25 @@
+package waitgroup
+
+import "sync"
+
+// Squares takes a slice of numbers and should return a slice
+// containing the square of each number.
+
+// Use goroutines to perform the calculations concurrently,
+// and use sync.WaitGroup to make sure all goroutines finish
+// before returning the results.
+
+// Steps:
+// 1. Create a channel to collect results.
+// 2. Start one goroutine per number.
+// 3. Each goroutine should send n*n into the channel.
+// 4. Wait for all goroutines to finish, then close the channel.
+// 5. Collect all values from the channel into a slice and return it.
+
+func Squares(nums []int) []int {
+	var wg sync.WaitGroup
+
+	// TODO: implement the logic here
+
+	return nil
+}

internal/exercises/templates/42_wait_group/wait_group_test.go

@@ -0,0 +1,45 @@
+package waitgroup
+
+import (
+	"reflect"
+	"sort"
+	"testing"
+	"time"
+)
+
+func equalIgnoreOrder(a, b []int) bool {
+	if len(a) != len(b) {
+		return false
+	}
+	x, y := append([]int(nil), a...), append([]int(nil), b...)
+	sort.Ints(x)
+	sort.Ints(y)
+	return reflect.DeepEqual(x, y)
+}
+
+func TestSquaresBasic(t *testing.T) {
+	got := Squares([]int{1, 2, 3, 4})
+	want := []int{1, 4, 9, 16}
+	if !equalIgnoreOrder(got, want) {
+		t.Fatalf("Squares() = %v; want %v", got, want)
+	}
+}
+
+func TestSquaresEmpty(t *testing.T) {
+	if len(Squares([]int{})) != 0 {
+		t.Fatal("expected empty result for empty input")
+	}
+}
+
+func TestSquaresTimeout(t *testing.T) {
+	done := make(chan struct{})
+	go func() {
+		_ = Squares([]int{5, 6, 7})
+		close(done)
+	}()
+	select {
+	case <-done:
+	case <-time.After(2 * time.Second):
+		t.Fatal("function deadlocked")
+	}
+}