Add solutions for Challenges 1-7 by shahzodshafizod (#1466)

* shahzodshafizod: challenges 1-4

* fixing os.Exit

* fixing comments

* removed out commented out alternative solution

* fixed new method that does not exist in earlier versions

* challenges 5-6

* challenge 7

* optimizing solution for challenge 7

---------

Co-authored-by: Shahzod Shafizod <shafizod@bankplanet9.com>

Author: shahzodshafizod

challenge-1/submissions/shahzodshafizod/solution-template.go

@@ -0,0 +1,37 @@
+package main
+
+import (
+	"errors"
+	"fmt"
+	"math"
+)
+
+var (
+	errOverflow = errors.New("errOverflow")
+)
+
+func main() {
+	var a, b int
+	// Read two integers from standard input
+	_, err := fmt.Scanf("%d, %d", &a, &b)
+	if err != nil {
+		fmt.Println("Error reading input:", err)
+		return
+	}
+
+	// Call the Sum function and print the result
+	result, err := Sum(a, b)
+	if err != nil {
+		fmt.Println(err)
+		return
+	}
+	fmt.Println(result)
+}
+
+// Sum returns the sum of a and b.
+func Sum(a int, b int) (int, error) {
+	if a > 0 && b > math.MaxInt-a || a < 0 && b < math.MinInt-a {
+		return 0, errOverflow
+	}
+	return a + b, nil
+}

challenge-2/submissions/shahzodshafizod/solution-template.go

@@ -0,0 +1,29 @@
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+	"slices"
+)
+
+func main() {
+	// Read input from standard input
+	scanner := bufio.NewScanner(os.Stdin)
+	if scanner.Scan() {
+		input := scanner.Text()
+
+		// Call the ReverseString function
+		output := ReverseString(input)
+
+		// Print the result
+		fmt.Println(output)
+	}
+}
+
+// ReverseString returns the reversed string of s.
+func ReverseString(s string) string {
+	sr := []rune(s)
+	slices.Reverse(sr)
+	return string(sr)
+}

challenge-3/submissions/shahzodshafizod/solution-template.go

@@ -0,0 +1,77 @@
+package main
+
+import (
+	"fmt"
+	"sync"
+)
+
+type Employee struct {
+	ID     int
+	Name   string
+	Age    int
+	Salary float64
+}
+
+type Manager struct {
+	Employees   []Employee
+	totalSalary float64
+	mu          sync.RWMutex
+}
+
+// AddEmployee adds a new employee to the manager's list.
+func (m *Manager) AddEmployee(e Employee) { // O(1) or O(n)
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	m.Employees = append(m.Employees, e) // O(1) or O(n)
+	m.totalSalary += e.Salary
+}
+
+// RemoveEmployee removes an employee by ID from the manager's list.
+func (m *Manager) RemoveEmployee(id int) bool { // O(n)
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	for index := range m.Employees {
+		if m.Employees[index].ID == id {
+			m.totalSalary -= m.Employees[index].Salary
+			m.Employees = append(m.Employees[:index], m.Employees[index+1:]...)
+			return true
+		}
+	}
+	return false
+}
+
+// GetAverageSalary calculates the average salary of all employees.
+func (m *Manager) GetAverageSalary() float64 { // O(1)
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	if len(m.Employees) == 0 {
+		return 0
+	}
+	return m.totalSalary / float64(len(m.Employees))
+}
+
+// FindEmployeeByID finds and returns an employee by their ID.
+func (m *Manager) FindEmployeeByID(id int) *Employee { // O(n)
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	for index := range m.Employees {
+		if m.Employees[index].ID == id {
+			return &m.Employees[index]
+		}
+	}
+	return nil
+}
+
+func main() {
+	manager := Manager{}
+	manager.AddEmployee(Employee{ID: 1, Name: "Alice", Age: 30, Salary: 70000})
+	manager.AddEmployee(Employee{ID: 2, Name: "Bob", Age: 25, Salary: 65000})
+	manager.RemoveEmployee(1)
+	averageSalary := manager.GetAverageSalary()
+	employee := manager.FindEmployeeByID(2)
+
+	fmt.Printf("Average Salary: %f\n", averageSalary)
+	if employee != nil {
+		fmt.Printf("Employee found: %+v\n", *employee)
+	}
+}

challenge-4/submissions/shahzodshafizod/solution-template.go

@@ -0,0 +1,95 @@
+package main
+
+import (
+	"fmt"
+	"sync"
+)
+
+// ConcurrentBFSQueries concurrently processes BFS queries on the provided graph.
+// - graph: adjacency list, e.g., graph[u] = []int{v1, v2, ...}
+// - queries: a list of starting nodes for BFS.
+// - numWorkers: how many goroutines can process BFS queries simultaneously.
+//
+// Return a map from the query (starting node) to the BFS order as a slice of nodes.
+// YOU MUST use concurrency (goroutines + channels) to pass the performance tests.
+func ConcurrentBFSQueries(graph map[int][]int, queries []int, numWorkers int) map[int][]int {
+	if numWorkers <= 0 {
+		return map[int][]int{}
+	}
+
+	type Result struct {
+		start int
+		order []int
+	}
+
+	jobChan := make(chan int)
+	resultChan := make(chan Result)
+
+	var wg sync.WaitGroup
+	for range numWorkers {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			for start := range jobChan {
+				order := bfs(graph, start)
+				resultChan <- Result{start, order}
+			}
+		}()
+	}
+	go func() {
+		wg.Wait()
+		close(resultChan)
+	}()
+
+	go func() {
+		for _, start := range queries {
+			jobChan <- start
+		}
+		close(jobChan)
+	}()
+
+	results := make(map[int][]int)
+	for result := range resultChan {
+		results[result.start] = result.order
+	}
+
+	return results
+}
+
+func bfs(graph map[int][]int, start int) []int {
+	var neighbors []int
+	queue := []int{start}
+	seen := map[int]bool{start: true}
+	for n := len(queue); n > 0; n = len(queue) {
+		for i := range n {
+			node := queue[i]
+			neighbors = append(neighbors, node)
+			for _, nei := range graph[node] {
+				if !seen[nei] {
+					queue = append(queue, nei)
+					seen[nei] = true
+				}
+			}
+		}
+		queue = queue[n:]
+	}
+	return neighbors
+}
+
+func main() {
+	// You can insert optional local tests here if desired.
+	graph := map[int][]int{
+		0: {1, 2},
+		1: {2, 3},
+		2: {3},
+		3: {4},
+		4: {},
+	}
+	queries := []int{0, 1, 2}
+	numWorkers := 2
+
+	results := ConcurrentBFSQueries(graph, queries, numWorkers)
+	for start, order := range results {
+		fmt.Printf("%d -> %v\n", start, order)
+	}
+}

challenge-5/submissions/shahzodshafizod/solution-template.go

@@ -0,0 +1,57 @@
+package main
+
+import (
+	"fmt"
+	"net/http"
+)
+
+const validToken = "secret"
+
+// AuthMiddleware checks the "X-Auth-Token" header.
+// If it's "secret", call the next handler.
+// Otherwise, respond with 401 Unauthorized.
+func AuthMiddleware(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		// TODO: Implement the logic:
+		//  1) Grab the "X-Auth-Token" header
+		//  2) Compare against validToken
+		//  3) If mismatch or missing, respond with 401
+		//  4) Otherwise pass to next handler
+		token := r.Header.Get("X-Auth-Token")
+		if token == "" || token != validToken {
+			http.Error(w, "", http.StatusUnauthorized)
+			return
+		}
+		next.ServeHTTP(w, r)
+	})
+}
+
+// helloHandler returns "Hello!" on GET /hello
+func helloHandler(w http.ResponseWriter, r *http.Request) {
+	fmt.Fprint(w, "Hello!")
+}
+
+// secureHandler returns "You are authorized!" on GET /secure
+func secureHandler(w http.ResponseWriter, r *http.Request) {
+	fmt.Fprint(w, "You are authorized!")
+}
+
+// SetupServer configures the HTTP routes with the authentication middleware.
+func SetupServer() http.Handler {
+	mux := http.NewServeMux()
+
+	// Public route: /hello (no auth required)
+	mux.HandleFunc("/hello", helloHandler)
+
+	// Secure route: /secure
+	// Wrap with AuthMiddleware
+	secureRoute := http.HandlerFunc(secureHandler)
+	mux.Handle("/secure", AuthMiddleware(secureRoute))
+
+	return mux
+}
+
+func main() {
+	// Optional: you can run a real server for local testing
+	http.ListenAndServe(":8081", SetupServer())
+}

challenge-6/submissions/shahzodshafizod/solution-template.go

@@ -0,0 +1,30 @@
+// Package challenge6 contains the solution for Challenge 6.
+package challenge6
+
+import (
+	"strings"
+	"unicode"
+)
+
+// CountWordFrequency takes a string containing multiple words and returns
+// a map where each key is a word and the value is the number of times that
+// word appears in the string. The comparison is case-insensitive.
+//
+// Words are defined as sequences of letters and digits.
+// All words are converted to lowercase before counting.
+// All punctuation, spaces, and other non-alphanumeric characters are ignored.
+//
+// For example:
+// Input: "The quick brown fox jumps over the lazy dog."
+// Output: map[string]int{"the": 2, "quick": 1, "brown": 1, "fox": 1, "jumps": 1, "over": 1, "lazy": 1, "dog": 1}
+func CountWordFrequency(text string) map[string]int {
+	text = strings.ToLower(strings.ReplaceAll(text, "'", ""))
+	freq := make(map[string]int)
+
+	for _, word := range strings.FieldsFunc(text, func(r rune) bool {
+		return !unicode.IsLetter(r) && !unicode.IsDigit(r)
+	}) {
+		freq[word]++
+	}
+	return freq
+}