shahzodshafizod: challenges 1-4

Author: Shahzod Shafizod

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

@@ -0,0 +1,38 @@
+package main
+
+import (
+	"errors"
+	"fmt"
+	"math"
+	"os"
+)
+
+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)
+		os.Exit(1)
+	}
+
+	// Call the Sum function and print the result
+	result, err := Sum(a, b)
+	if err != nil {
+		fmt.Println(err)
+		os.Exit(1)
+	}
+	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-1/submissions/shahzodshafizod/solution-template_test.go

@@ -0,0 +1,48 @@
+package main
+
+import (
+	"bytes"
+	"fmt"
+	"math"
+	"os/exec"
+	"strings"
+	"testing"
+)
+
+// go test -v challenge-1/submissions/shahzodshafizod/solution-template_test.go
+func TestSum(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    string
+		expected string
+	}{
+		{"Positive numbers", "2, 3", "5"},
+		{"Zero values", "0, 0", "0"},
+		{"Negative numbers", "-2, -3", "-5"},
+		{"Mixed signs", "-5, 10", "5"},
+		{"Large numbers", "1000000000, 1000000000", "2000000000"},
+		{"Overflow case", fmt.Sprintf("%d, %d", math.MaxInt, math.MaxInt), "errOverflow"},
+		{"Overflow case", fmt.Sprintf("%d, %d", math.MinInt, math.MinInt), "errOverflow"},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			cmd := exec.Command("go", "run", "solution-template.go")
+			stdin := strings.NewReader(tt.input)
+			var stdout, stderr bytes.Buffer
+			cmd.Stdin = stdin
+			cmd.Stdout = &stdout
+			cmd.Stderr = &stderr
+
+			err := cmd.Run()
+			if err != nil {
+				t.Fatalf("Error running the program: %v\nStderr: %s", err, stderr.String())
+			}
+
+			output := strings.TrimSpace(stdout.String())
+			if output != tt.expected {
+				t.Errorf("For input '%s', expected output '%s', got '%s'", tt.input, tt.expected, output)
+			}
+		})
+	}
+}

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-2/submissions/shahzodshafizod/solution-template_test.go

@@ -0,0 +1,45 @@
+package main
+
+import (
+	"bytes"
+	"os/exec"
+	"strings"
+	"testing"
+)
+
+// go test -v challenge-2/submissions/shahzodshafizod/solution-template_test.go
+func TestReverseString(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    string
+		expected string
+	}{
+		{"Simple word", "hello", "olleh"},
+		{"Sentence with spaces", "Go is fun!", "!nuf si oG"},
+		{"Empty string", "", ""},
+		{"Palindrome", "madam", "madam"},
+		{"Special characters", "12345!@#$%", "%$#@!54321"},
+		{"Mixed case", "GoLang", "gnaLoG"},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			cmd := exec.Command("go", "run", "solution-template.go")
+			stdin := strings.NewReader(tt.input)
+			var stdout, stderr bytes.Buffer
+			cmd.Stdin = stdin
+			cmd.Stdout = &stdout
+			cmd.Stderr = &stderr
+
+			err := cmd.Run()
+			if err != nil {
+				t.Fatalf("Error running the program: %v\nStderr: %s", err, stderr.String())
+			}
+
+			output := strings.TrimSpace(stdout.String())
+			if output != tt.expected {
+				t.Errorf("For input '%s', expected output '%s', got '%s'", tt.input, tt.expected, output)
+			}
+		})
+	}
+}

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

@@ -0,0 +1,95 @@
+package main
+
+import (
+	"fmt"
+	"sort"
+	"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) { // Time: O(n)
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	// sort.Slice(m.Employees, func(i, j int) bool {
+	// 	return m.Employees[i].ID < m.Employees[j].ID
+	// })
+	idx := m.search(e.ID)
+	if idx == -1 {
+		idx = len(m.Employees)
+	}
+	m.Employees = append(m.Employees, Employee{})
+	copy(m.Employees[idx+1:], m.Employees[idx:])
+	m.Employees[idx] = e
+	m.totalSalary += e.Salary
+}
+
+// RemoveEmployee removes an employee by ID from the manager's list.
+func (m *Manager) RemoveEmployee(id int) bool { // Time: O(n)
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	index := m.search(id) // O(log n)
+	if index != -1 {
+		m.totalSalary -= m.Employees[index].Salary
+		m.Employees = append(m.Employees[:index], m.Employees[index+1:]...) // O(n)
+		return true
+	}
+	return false
+}
+
+// GetAverageSalary calculates the average salary of all employees.
+func (m *Manager) GetAverageSalary() float64 { // Time: O(1)
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	if n := len(m.Employees); n > 0 {
+		return m.totalSalary / float64(n)
+	}
+	return 0
+}
+
+// FindEmployeeByID finds and returns an employee by their ID.
+func (m *Manager) FindEmployeeByID(id int) *Employee { // Time: O(log n)
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	index := m.search(id)
+	if index != -1 {
+		return &m.Employees[index]
+	}
+	return nil
+}
+
+func (m *Manager) search(id int) int { // Time: O(log n)
+	index := sort.Search(len(m.Employees), func(i int) bool {
+		return m.Employees[i].ID >= id
+	}) // sort.Search returns an index where a new item could be inserted, so we do not receive -1 or an error
+	if index < len(m.Employees) && m.Employees[index].ID == id {
+		return index
+	}
+	return -1
+}
+
+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-3/submissions/shahzodshafizod/solution-template_test.go

@@ -0,0 +1,99 @@
+package main
+
+import (
+	"testing"
+)
+
+// go test -C challenge-3 -v -count 1 ./submissions/shahzodshafizod/
+func TestAddEmployee(t *testing.T) {
+	manager := Manager{}
+
+	manager.AddEmployee(Employee{ID: 1, Name: "Alice", Age: 30, Salary: 70000})
+	manager.AddEmployee(Employee{ID: 2, Name: "Bob", Age: 25, Salary: 65000})
+
+	if len(manager.Employees) != 2 {
+		t.Errorf("Expected 2 employees, got %d", len(manager.Employees))
+	}
+
+	// Edge Case: Add an Employee with an Existing ID
+	manager.AddEmployee(Employee{ID: 1, Name: "Derek", Age: 40, Salary: 80000})
+	if len(manager.Employees) != 3 {
+		t.Errorf("Expected 3 employees despite duplicate ID, got %d", len(manager.Employees))
+	}
+}
+
+func TestRemoveEmployee(t *testing.T) {
+	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)
+	if len(manager.Employees) != 1 {
+		t.Errorf("Expected 1 employee after removing ID 1, got %d", len(manager.Employees))
+	}
+
+	// Remove Non-Existing Employee
+	manager.RemoveEmployee(999)
+	if len(manager.Employees) != 1 {
+		t.Errorf("Expected 1 employee after attempting to remove non-existing ID, got %d", len(manager.Employees))
+	}
+}
+
+func TestGetAverageSalary(t *testing.T) {
+	manager := Manager{}
+
+	manager.AddEmployee(Employee{ID: 2, Name: "Bob", Age: 25, Salary: 65000})
+	manager.AddEmployee(Employee{ID: 3, Name: "Charlie", Age: 35, Salary: 75000})
+
+	var expectedAverage float64
+	expectedAverage = (65000 + 75000) / 2
+	if avg := manager.GetAverageSalary(); avg != expectedAverage {
+		t.Errorf("Expected average salary %f, got %f", expectedAverage, avg)
+	}
+
+	// Edge Case: GetAverageSalary with No Employees
+	manager.Employees = []Employee{}
+
+	expectedAverage = 0
+
+	if avg := manager.GetAverageSalary(); avg != expectedAverage {
+		t.Errorf("Expected average salary %f with no employees, got %f", expectedAverage, avg)
+	}
+}
+
+func TestFindEmployeeByID(t *testing.T) {
+	manager := Manager{}
+
+	manager.AddEmployee(Employee{ID: 2, Name: "Bob", Age: 25, Salary: 65000})
+	manager.AddEmployee(Employee{ID: 3, Name: "Charlie", Age: 35, Salary: 75000})
+
+	employee := manager.FindEmployeeByID(2)
+	if employee == nil || employee.Name != "Bob" {
+		t.Errorf("Expected to find Bob, got %+v", employee)
+	}
+
+	employee = manager.FindEmployeeByID(999)
+	if employee != nil {
+		t.Errorf("Expected no employee, got %+v", employee)
+	}
+}
+
+func TestFindEmployeeAfterRemoval(t *testing.T) {
+	manager := Manager{}
+
+	manager.AddEmployee(Employee{ID: 4, Name: "David", Age: 45, Salary: 100000})
+	manager.AddEmployee(Employee{ID: 5, Name: "Eva", Age: 29, Salary: 95000})
+
+	employee := manager.FindEmployeeByID(4)
+	if employee == nil || employee.Name != "David" {
+		t.Errorf("Expected to find David, got %+v", employee)
+	}
+
+	// Edge Case: Test FindEmployeeByID After Removal
+	manager.RemoveEmployee(4)
+	employee = manager.FindEmployeeByID(4)
+	if employee != nil {
+		t.Errorf("Expected no employee, got %+v", employee)
+	}
+}