Merge pull request #1 from vatsalpatel/array_functions

Implement Array functions with tests

Author: vatsalpatel

arrays.go

@@ -0,0 +1,339 @@
+package ut
+
+import (
+	"fmt"
+	"math/rand"
+	"time"
+)
+
+// Chunk splits a slice into chunks of a specified size
+func Chunk[T any](arr []T, size int) [][]T {
+	length := len(arr)
+	if size <= 0 || length == 0 {
+		return nil
+	}
+
+	chunks := make([][]T, 0)
+	for i := 0; i < length; i += size {
+		end := i + size
+		if end > length {
+			end = length
+		}
+		chunks = append(chunks, arr[i:end])
+	}
+
+	return chunks
+}
+
+// Concat concatenates two or more slices into a single slice
+func Concat[T any](arrays ...[]T) []T {
+	length := 0
+	for _, arr := range arrays {
+		length += len(arr)
+	}
+
+	concatenated := make([]T, 0, length)
+	for _, arr := range arrays {
+		concatenated = append(concatenated, arr...)
+	}
+
+	return concatenated
+}
+
+// Difference creates a slice of values that are not in the other given slices
+func Difference[T comparable](arr []T, others ...[]T) []T {
+	diffSet := make(map[T]struct{})
+	for _, val := range arr {
+		diffSet[val] = struct{}{}
+	}
+
+	for _, other := range others {
+		for _, val := range other {
+			delete(diffSet, val)
+		}
+	}
+
+	difference := make([]T, 0, len(diffSet))
+	for val := range diffSet {
+		difference = append(difference, val)
+	}
+
+	return difference
+}
+
+// Every checks if all elements in the slice satisfy the given predicate.
+// The predicate is invoked with three arguments: (value, index, array).
+// It returns true if the predicate returns true for all elements, otherwise false.
+func Every[T any](arr []T, predicate func(T, int, []T) bool) bool {
+	for i, value := range arr {
+		if !predicate(value, i, arr) {
+			return false
+		}
+	}
+	return true
+}
+
+// Fill modifies a slice by filling it with a specified value from a start index to an end index
+func Fill(arr []interface{}, value interface{}, start int, end int) {
+	length := len(arr)
+	if start < 0 {
+		start = 0
+	}
+	if end > length {
+		end = length
+	}
+	for i := start; i < end; i++ {
+		arr[i] = value
+	}
+}
+
+// Filter filters the elements of a slice based on a predicate function.
+// The predicate function is invoked with three arguments: (value, index, arg),
+// and should return a boolean indicating whether the value should be included in the result.
+func Filter[T any](arr []T, predicate func(int, T, interface{}) bool, arg interface{}) []T {
+	var result []T
+
+	for i, value := range arr {
+		if predicate(i, value, arg) {
+			result = append(result, value)
+		}
+	}
+
+	return result
+}
+
+// FindIndex returns the index of the first element in a slice that satisfies the provided testing function
+func FindIndex(arr []interface{}, predicate func(interface{}) bool) int {
+	for i, val := range arr {
+		if predicate(val) {
+			return i
+		}
+	}
+	return -1
+}
+
+// Flatten flattens a slice of slices into a single slice
+func Flatten(arr []interface{}) []interface{} {
+	flattened := make([]interface{}, 0)
+	for _, val := range arr {
+		switch v := val.(type) {
+		case []interface{}:
+			flattened = append(flattened, Flatten(v)...)
+		default:
+			flattened = append(flattened, v)
+		}
+	}
+	return flattened
+}
+
+// Includes checks if a given value is present in the slice.
+// It returns true if the value is found, otherwise false.
+func Includes[T comparable](arr []T, value T) bool {
+	for _, item := range arr {
+		if item == value {
+			return true
+		}
+	}
+	return false
+}
+
+// Intersection returns an array containing the unique values that are present in all of the input arrays.
+func Intersection(arrays ...[]interface{}) []interface{} {
+	// Count occurrences of each element
+	counts := make(map[interface{}]int)
+	for _, arr := range arrays {
+		seen := make(map[interface{}]bool)
+		for _, elem := range arr {
+			if !seen[elem] {
+				counts[elem]++
+				seen[elem] = true
+			}
+		}
+	}
+
+	// Filter elements that appear in all arrays
+	var result []interface{}
+	for elem, count := range counts {
+		if count == len(arrays) {
+			result = append(result, elem)
+		}
+	}
+
+	return result
+}
+
+// Join concatenates all elements of an array into a single string using the provided separator.
+func Join(arr []interface{}, separator string) string {
+	if len(arr) == 0 {
+		return ""
+	}
+
+	var result string
+	for i, elem := range arr {
+		if i > 0 {
+			result += separator
+		}
+		result += fmt.Sprintf("%v", elem)
+	}
+
+	return result
+}
+
+// Map applies a transformation function to each element of the input array/slice
+// and returns a new array/slice with the transformed values.
+func Map[T any, U any](arr []T, transformFunc func(int, T, interface{}) U, arg interface{}) []U {
+	result := make([]U, len(arr))
+
+	for i, element := range arr {
+		transformedValue := transformFunc(i, element, arg)
+		result[i] = transformedValue
+	}
+
+	return result
+}
+
+// Pull removes all occurrences of the specified values from a slice.
+func Pull[T comparable](arr []T, values ...T) []T {
+	var result []T
+	excluded := make(map[T]struct{})
+
+	for _, value := range values {
+		excluded[value] = struct{}{}
+	}
+
+	for _, item := range arr {
+		if _, excluded := excluded[item]; !excluded {
+			result = append(result, item)
+		}
+	}
+
+	return result
+}
+
+// Reduce applies a function against an accumulator and each element in the slice (from left to right)
+// to reduce it to a single value.
+// The transform function is invoked with four arguments: (accumulator, value, index, arg).
+// The initial value of the accumulator is provided as the initialValue parameter.
+func Reduce[T any, R any](arr []T, transform func(R, T, int, interface{}) R, initialValue R, arg interface{}) R {
+	accumulator := initialValue
+
+	for i, value := range arr {
+		accumulator = transform(accumulator, value, i, arg)
+	}
+
+	return accumulator
+}
+
+// Remove removes all elements from the slice for which the predicate returns truthy,
+// and returns an array of the removed elements.
+// The predicate is invoked with three arguments: (value, index, array).
+func Remove[T any](arr *[]T, predicate func(T, int, []T) bool) []T {
+	var removed []T
+	remaining := (*arr)[:0]
+
+	for index, value := range *arr {
+		if predicate(value, index, *arr) {
+			removed = append(removed, value)
+		} else {
+			remaining = append(remaining, value)
+		}
+	}
+
+	*arr = remaining
+	return removed
+}
+
+// Reverse reverses the elements of a slice in place
+func Reverse[T any](arr []T) {
+	for i, j := 0, len(arr)-1; i < j; i, j = i+1, j-1 {
+		arr[i], arr[j] = arr[j], arr[i]
+	}
+}
+
+// Shuffle shuffles the elements of the slice using the Fisher-Yates algorithm. It modifies the input slice in place.
+func Shuffle[T any](arr []T) {
+	r := rand.New(rand.NewSource(time.Now().UnixNano()))
+	for i := len(arr) - 1; i > 0; i-- {
+		j := r.Intn(i + 1)
+		arr[i], arr[j] = arr[j], arr[i]
+	}
+}
+
+// Slice returns a portion of a slice from a start index to an end index
+func Slice[T any](arr []T, start, end int) []T {
+	if start < 0 {
+		start = 0
+	}
+	if end > len(arr) {
+		end = len(arr)
+	}
+	if start > end {
+		return nil
+	}
+	return arr[start:end]
+}
+
+// Some checks if at least one element in the slice satisfies the given predicate.
+// The predicate is invoked with three arguments: (value, index, array).
+// It returns true if the predicate returns true for any element, otherwise false.
+func Some[T any](arr []T, predicate func(T, int, []T) bool) bool {
+	for i, value := range arr {
+		if predicate(value, i, arr) {
+			return true
+		}
+	}
+	return false
+}
+
+// Union returns a new slice that contains the unique elements from all input slices.
+// The order of elements in the resulting slice is undefined.
+func Union[T comparable](slices ...[]T) []T {
+	// Use a map to track unique elements
+	uniqueElements := make(map[T]struct{})
+
+	for _, slice := range slices {
+		for _, elem := range slice {
+			uniqueElements[elem] = struct{}{}
+		}
+	}
+
+	// Build the resulting slice from the unique elements
+	result := make([]T, 0, len(uniqueElements))
+	for elem := range uniqueElements {
+		result = append(result, elem)
+	}
+
+	return result
+}
+
+// Uniq creates a new slice of unique values in the order of their first occurrence in the original slice
+func Uniq[T comparable](arr []T) []T {
+	seen := make(map[T]struct{})
+	var result []T
+
+	for _, value := range arr {
+		if _, exists := seen[value]; !exists {
+			seen[value] = struct{}{}
+			result = append(result, value)
+		}
+	}
+
+	return result
+}
+
+// Zip merges multiple slices into a single slice of tuples, where each tuple contains
+// the corresponding elements from each of the input slices.
+// The length of the resulting slice is determined by the shortest input slice.
+func Zip[T1, T2 interface{}](slice1 []T1, slice2 []T2) [][]interface{} {
+	length := len(slice1)
+	if len(slice2) < length {
+		length = len(slice2)
+	}
+
+	zipped := make([][]interface{}, length)
+	for i := 0; i < length; i++ {
+		zipped[i] = []interface{}{slice1[i], slice2[i]}
+	}
+
+	return zipped
+}