Add solutions by odelbos (#64)

* Add solution for Challenge 27 by odelbos

* Add solution for Challenge 9 by odelbos

Author: odelbos

challenge-27/submissions/odelbos/solution-template.go

@@ -0,0 +1,269 @@
+package generics
+
+import (
+	"errors"
+	"slices"
+)
+
+// ErrEmptyCollection is returned when an operation cannot be performed on an empty collection
+var ErrEmptyCollection = errors.New("collection is empty")
+
+//
+// 1. Generic Pair
+//
+
+// Pair represents a generic pair of values of potentially different types
+type Pair[T, U any] struct {
+	First  T
+	Second U
+}
+
+// NewPair creates a new pair with the given values
+func NewPair[T, U any](first T, second U) Pair[T, U] {
+	return Pair[T, U]{First: first, Second: second}
+}
+
+// Swap returns a new pair with the elements swapped
+func (p Pair[T, U]) Swap() Pair[U, T] {
+	return Pair[U, T]{First: p.Second, Second: p.First}
+}
+
+//
+// 2. Generic Stack
+//
+
+// Stack is a generic Last-In-First-Out (LIFO) data structure
+type Stack[T any] struct {
+	items []T
+}
+
+// NewStack creates a new empty stack
+func NewStack[T any]() *Stack[T] {
+	return &Stack[T]{items: make([]T, 0)}
+}
+
+// Push adds an element to the top of the stack
+func (s *Stack[T]) Push(value T) {
+	s.items = append(s.items, value)
+}
+
+// Pop removes and returns the top element from the stack
+// Returns an error if the stack is empty
+func (s *Stack[T]) Pop() (T, error) {
+	if s.IsEmpty() {
+		var zero T
+		return zero, ErrEmptyCollection
+	}
+	idx := len(s.items) - 1
+	val := s.items[idx]
+	s.items = s.items[:idx]
+	return val, nil
+}
+
+// Peek returns the top element without removing it
+// Returns an error if the stack is empty
+func (s *Stack[T]) Peek() (T, error) {
+	if s.IsEmpty() {
+		var zero T
+		return zero, ErrEmptyCollection
+	}
+	return s.items[len(s.items)-1], nil
+}
+
+// Size returns the number of elements in the stack
+func (s *Stack[T]) Size() int {
+	return len(s.items)
+}
+
+// IsEmpty returns true if the stack contains no elements
+func (s *Stack[T]) IsEmpty() bool {
+	return len(s.items) == 0
+}
+
+//
+// 3. Generic Queue
+//
+
+// Queue is a generic First-In-First-Out (FIFO) data structure
+type Queue[T any] struct {
+	items []T
+}
+
+// NewQueue creates a new empty queue
+func NewQueue[T any]() *Queue[T] {
+	return &Queue[T]{items: make([]T, 0)}
+}
+
+// Enqueue adds an element to the end of the queue
+func (q *Queue[T]) Enqueue(value T) {
+	q.items = append(q.items, value)
+}
+
+// Dequeue removes and returns the front element from the queue
+// Returns an error if the queue is empty
+func (q *Queue[T]) Dequeue() (T, error) {
+	if q.IsEmpty() {
+		var zero T
+		return zero, ErrEmptyCollection
+	}
+	val := q.items[0]
+	q.items = q.items[1:]
+	return val, nil
+}
+
+// Front returns the front element without removing it
+// Returns an error if the queue is empty
+func (q *Queue[T]) Front() (T, error) {
+	if q.IsEmpty() {
+		var zero T
+		return zero, ErrEmptyCollection
+	}
+	return q.items[0], nil
+}
+
+// Size returns the number of elements in the queue
+func (q *Queue[T]) Size() int {
+	return len(q.items)
+}
+
+// IsEmpty returns true if the queue contains no elements
+func (q *Queue[T]) IsEmpty() bool {
+	return len(q.items) == 0
+}
+
+//
+// 4. Generic Set
+//
+
+// Set is a generic collection of unique elements
+type Set[T comparable] struct {
+	items map[T]struct{}
+}
+
+// NewSet creates a new empty set
+func NewSet[T comparable]() *Set[T] {
+	return &Set[T]{items: make(map[T]struct{})}
+}
+
+// Add adds an element to the set if it's not already present
+func (s *Set[T]) Add(value T) {
+	s.items[value] = struct{}{}
+}
+
+// Remove removes an element from the set if it exists
+func (s *Set[T]) Remove(value T) {
+	delete(s.items, value)
+}
+
+// Contains returns true if the set contains the given element
+func (s *Set[T]) Contains(value T) bool {
+	_, ok := s.items[value]
+	return ok
+}
+
+// Size returns the number of elements in the set
+func (s *Set[T]) Size() int {
+	return len(s.items)
+}
+
+// Elements returns a slice containing all elements in the set
+func (s *Set[T]) Elements() []T {
+	result := make([]T, 0, len(s.items))
+	for val := range(s.items) {
+		result = append(result, val)
+	}
+	return result
+}
+
+// Union returns a new set containing all elements from both sets
+func Union[T comparable](s1, s2 *Set[T]) *Set[T] {
+	result := NewSet[T]()
+	for val := range(s1.items) {
+		result.Add(val)
+	}
+	for val := range(s2.items) {
+		result.Add(val)
+	}
+	return result
+}
+
+// Intersection returns a new set containing only elements that exist in both sets
+func Intersection[T comparable](s1, s2 *Set[T]) *Set[T] {
+	result := NewSet[T]()
+	for val := range(s1.items) {
+		if s2.Contains(val) {
+			result.Add(val)
+		}
+	}
+	return result
+}
+
+// Difference returns a new set with elements in s1 that are not in s2
+func Difference[T comparable](s1, s2 *Set[T]) *Set[T] {
+	result := NewSet[T]()
+	for val := range(s1.items) {
+		if ! s2.Contains(val) {
+			result.Add(val)
+		}
+	}
+	return result
+}
+
+//
+// 5. Generic Utility Functions
+//
+
+// Filter returns a new slice containing only the elements for which the predicate returns true
+func Filter[T any](slice []T, predicate func(T) bool) []T {
+	result := make([]T, 0)
+	for _, val := range(slice) {
+		if predicate(val) {
+			result = append(result, val)
+		}
+	}
+	return result
+}
+
+// Map applies a function to each element in a slice and returns a new slice with the results
+func Map[T, U any](slice []T, mapper func(T) U) []U {
+	result := make([]U, len(slice))
+	for i, val := range(slice) {
+		result[i] = mapper(val)
+	}
+	return result
+}
+
+// Reduce reduces a slice to a single value by applying a function to each element
+func Reduce[T, U any](slice []T, initial U, reducer func(U, T) U) U {
+	result := initial
+	for _, val := range(slice) {
+		result = reducer(result, val)
+	}
+	return result
+}
+
+// Contains returns true if the slice contains the given element
+func Contains[T comparable](slice []T, element T) bool {
+	return slices.Contains(slice, element)
+}
+
+// FindIndex returns the index of the first occurrence of the given element or -1 if not found
+func FindIndex[T comparable](slice []T, element T) int {
+	for i, val := range(slice) {
+		if val == element {
+			return i
+		}
+	}
+	return -1
+}
+
+// RemoveDuplicates returns a new slice with duplicate elements removed, preserving order
+func RemoveDuplicates[T comparable](slice []T) []T {
+	result := make([]T, 0)
+	for _, val := range(slice) {
+		if ! slices.Contains(result, val) {
+			result = append(result, val)
+		}
+	}
+	return result
+}