Merge branch 'main' into rate_limiting

Signed-off-by: Kaushalya Pradeep <24698778+kaushalyap@users.noreply.github.com>

Author: kawpii

internal/exercises/catalog.yaml

@@ -197,6 +197,27 @@ concepts:
   hints:
     - Use `select` to handle multiple channel operations concurrently.
     - Use `time.After` to simulate a 5 microsecond timeout.
+- slug: 41_time_delay
+  title: "Delays and Timers in Go"
+  difficulty: beginner
+  topics: ["time", "sleep", "channels", "timer"]
+  test_regex: ".*"
+  hints:
+    - "Use time.Sleep() to pause execution for a duration."
+    - "Convert milliseconds to time.Duration using time.Millisecond."
+    - "Use a buffered channel to send a signal after waiting."
+    - "Use time.After or time.Sleep to trigger events after delays."
+- 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)
@@ -276,6 +297,30 @@ projects:
       - "Use time.LoadLocation() to work with different timezones"
       - "Extract time components using .Date() and .Clock() methods"
 
+- slug: 39_panic
+  title: Panic and Recover
+  test_regex: ".*"
+  hints:
+    - "Use `panic()` to simulate runtime errors when appropriate."
+    - "Use `defer` with `recover()` to catch and handle panics."
+    - "Recovering from panics allows graceful handling of unexpected situations."
+    - "Remember: `recover()` only works inside a deferred function."
+
+- slug: 64_timers
+  title: "Timers"
+  difficulty: medium
+  topics: ["time", "goroutines", "concurrency", "synchronization"]
+  test_regex: ".*"
+  hints:
+    - "Use a map[string]*time.Timer to track active timers by key."
+    - "Use a mutex to safely access the timers map concurrently."
+    - "Start a timer with time.AfterFunc(d, fn) to run a callback after duration d."
+    - "If Start is called again for an existing key, stop and replace the old timer."
+    - "Stop should remove the timer from the map and prevent the callback from firing."
+    - "Reset can call timer.Reset(d) to reschedule the same callback."
+    - "Remember to remove timers from the map after they fire to avoid memory leaks."
+    - "Write tests to verify Start, Stop, and Reset behavior, including concurrency scenarios."
+    
 - slug: 68_rate_limiting
   title: Rate Limiting
   test_regex: ".*"
@@ -288,4 +333,4 @@ projects:
     - "Reset should clear the request history for a key; if the key does not exist, do nothing."
     - "Consider edge cases: multiple keys, concurrent access, and requests exactly at the interval boundary."
     - "In tests, use time.Sleep with a small buffer above the interval to avoid flakiness."
-    - "Initialize the timestamps map in NewRateLimiter to prevent nil pointer errors."
+    - "Initialize the timestamps map in NewRateLimiter to prevent nil pointer errors."

internal/exercises/solutions/39_panic/panic.go

@@ -0,0 +1,38 @@
+package panicex
+
+// SafeDivision divides a by b, recovers from panic if denominator is zero
+func SafeDivision(a, b int) (result int) {
+	defer func() {
+		if r := recover(); r != nil {
+			result = 0
+		}
+	}()
+	if b == 0 {
+		panic("divide by zero")
+	}
+	return a / b
+}
+
+// TriggerMultiplePanics demonstrates defer + recover in a loop
+func TriggerMultiplePanics(nums []int) []string {
+	results := make([]string, len(nums))
+	for i, v := range nums {
+		func(idx, val int) {
+			defer func() {
+				if r := recover(); r != nil {
+					results[idx] = "recovered panic"
+				}
+			}()
+			if val < 0 {
+				panic("panic for negative")
+			}
+			results[idx] = "ok"
+		}(i, v)
+	}
+	return results
+}
+
+// PanicWithMessage panics with a custom message
+func PanicWithMessage(msg string) {
+	panic(msg)
+}

internal/exercises/solutions/41_time_delay/time_delay.go

@@ -0,0 +1,90 @@
+package timedelay
+
+// Real implementations using time.Now, time.Add and comparisons for the exercise.
+
+import (
+	"errors"
+	"time"
+)
+
+// WaitFor pauses execution until roughly ms milliseconds have passed.
+func WaitFor(ms int) {
+	target := time.Now().Add(time.Duration(ms) * time.Millisecond)
+	for time.Now().Before(target) {
+		time.Sleep(1 * time.Millisecond)
+	}
+}
+
+// NotifyAfter returns a channel that receives true after roughly ms milliseconds.
+func NotifyAfter(ms int) chan bool {
+	ch := make(chan bool, 1)
+	target := time.Now().Add(time.Duration(ms) * time.Millisecond)
+
+	go func() {
+		for time.Now().Before(target) {
+			time.Sleep(1 * time.Millisecond)
+		}
+		ch <- true
+	}()
+
+	return ch
+}
+
+// WaitUntil blocks until the provided target time is reached (returns immediately if in the past).
+func WaitUntil(target time.Time) {
+	for time.Now().Before(target) {
+		time.Sleep(1 * time.Millisecond)
+	}
+}
+
+// NotifyAt returns a channel that receives true when target time is reached (sends immediately if in the past).
+func NotifyAt(target time.Time) chan bool {
+	ch := make(chan bool, 1)
+
+	go func() {
+		for time.Now().Before(target) {
+			time.Sleep(1 * time.Millisecond)
+		}
+		ch <- true
+	}()
+
+	return ch
+}
+
+// ElapsedMillis returns how many milliseconds have elapsed since t.
+func ElapsedMillis(t time.Time) int64 {
+	return time.Since(t).Milliseconds()
+}
+
+// WaitForOrTimeout waits up to ms milliseconds but fails if total waiting exceeds timeoutMs.
+func WaitForOrTimeout(ms int, timeoutMs int) error {
+	target := time.Now().Add(time.Duration(ms) * time.Millisecond)
+	deadline := time.Now().Add(time.Duration(timeoutMs) * time.Millisecond)
+
+	for {
+		now := time.Now()
+		if !now.Before(target) {
+			return nil
+		}
+		if !now.Before(deadline) {
+			return errors.New("timeout exceeded before target reached")
+		}
+		time.Sleep(1 * time.Millisecond)
+	}
+}
+
+// ScheduleAfter runs fn after roughly ms milliseconds and returns a channel closed when fn finishes.
+func ScheduleAfter(ms int, fn func()) chan struct{} {
+	done := make(chan struct{})
+	target := time.Now().Add(time.Duration(ms) * time.Millisecond)
+
+	go func() {
+		for time.Now().Before(target) {
+			time.Sleep(1 * time.Millisecond)
+		}
+		fn()
+		close(done)
+	}()
+
+	return done
+}

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/solutions/64_timers/timers.go

@@ -0,0 +1,66 @@
+package timers
+
+import (
+	"sync"
+	"time"
+)
+
+type TimerManager struct {
+	mu     sync.Mutex
+	timers map[string]*time.Timer
+}
+
+// NewTimerManager returns a new TimerManager with an initialized timers map.
+func NewTimerManager() *TimerManager {
+	return &TimerManager{
+		timers: make(map[string]*time.Timer),
+	}
+}
+
+// Start starts a timer for the given key to run the provided callback after duration d.
+// If a timer with the same key already exists, it should be stopped and replaced.
+func (tm *TimerManager) Start(key string, d time.Duration, fn func()) {
+	tm.mu.Lock()
+	defer tm.mu.Unlock()
+
+	if oldTimer, ok := tm.timers[key]; ok {
+		oldTimer.Stop()
+		delete(tm.timers, key)
+	}
+
+	timer := time.AfterFunc(d, func() {
+		tm.mu.Lock()
+		delete(tm.timers, key)
+		tm.mu.Unlock()
+
+		fn()
+	})
+
+	tm.timers[key] = timer
+}
+
+// Stop stops and removes the timer with the given key.
+// It returns true if the timer existed and was stopped, false otherwise.
+func (tm *TimerManager) Stop(key string) bool {
+	tm.mu.Lock()
+	defer tm.mu.Unlock()
+
+	if timer, ok := tm.timers[key]; ok {
+		timer.Stop()
+		delete(tm.timers, key)
+		return true
+	}
+
+	return false
+}
+
+// Reset resets the existing timer for the given key to expire after duration d again.
+// If no timer exists for that key, do nothing.
+func (tm *TimerManager) Reset(key string, d time.Duration) {
+	tm.mu.Lock()
+	defer tm.mu.Unlock()
+
+	if timer, ok := tm.timers[key]; ok {
+		timer.Reset(d)
+	}
+}

internal/exercises/templates/39_panic/panic.go

@@ -0,0 +1,18 @@
+package panicex
+
+// TODO:
+// - Implement SafeDivision to divide two numbers and recover from panic if denominator is zero
+// - Implement TriggerMultiplePanics to demonstrate defer + recover in a loop
+// - Implement PanicWithMessage to panic with a custom message
+
+func SafeDivision(a, b int) (result int) {
+	return 0
+}
+
+func TriggerMultiplePanics(nums []int) []string {
+	return nil
+}
+
+func PanicWithMessage(msg string) {
+	// panic with the given message
+}

internal/exercises/templates/39_panic/panic_test.go

@@ -0,0 +1,60 @@
+package exercises
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestSafeDivision(t *testing.T) {
+	t.Run("Normal Division", func(t *testing.T) {
+		result := SafeDivision(10, 2)
+		if result != 5 {
+			t.Errorf("SafeDivision(10, 2) = %d, want 5", result)
+		}
+	})
+
+	t.Run("Division By Zero", func(t *testing.T) {
+		result := SafeDivision(10, 0)
+		if result != 0 {
+			t.Errorf("SafeDivision(10, 0) = %d, want 0 (safe recovery)", result)
+		}
+	})
+}
+
+func TestTriggerMultiplePanics(t *testing.T) {
+	nums := []int{3, -1, 4, -2}
+	results := TriggerMultiplePanics(nums)
+
+	if results == nil {
+		t.Log("Placeholder implementation detected")
+		return
+	}
+
+	if len(results) != len(nums) {
+		t.Errorf("Expected %d results, got %d", len(nums), len(results))
+	}
+
+	for i, num := range nums {
+		if num < 0 && results[i] == "" {
+			t.Errorf("Expected non-empty result (recovery message) for negative number at index %d", i)
+		}
+	}
+}
+
+func TestPanicWithMessage(t *testing.T) {
+	defer func() {
+		if r := recover(); r != nil {
+			msg, ok := r.(string)
+			if !ok {
+				t.Errorf("Recovered panic is not a string: %v", r)
+			}
+			if !strings.Contains(msg, "expected panic") {
+				t.Errorf("Panic message %q does not contain expected text", msg)
+			}
+		} else {
+			t.Errorf("Expected panic, got none")
+		}
+	}()
+
+	PanicWithMessage("this is an expected panic")
+}