forked from Snider/Poindexter
89 lines
2.7 KiB
Go
89 lines
2.7 KiB
Go
package poindexter
|
|
|
|
import "sort"
|
|
|
|
// SortInts sorts a slice of integers in ascending order in place.
|
|
func SortInts(data []int) {
|
|
sort.Ints(data)
|
|
}
|
|
|
|
// SortIntsDescending sorts a slice of integers in descending order in place.
|
|
func SortIntsDescending(data []int) {
|
|
sort.Sort(sort.Reverse(sort.IntSlice(data)))
|
|
}
|
|
|
|
// SortStrings sorts a slice of strings in ascending order in place.
|
|
func SortStrings(data []string) {
|
|
sort.Strings(data)
|
|
}
|
|
|
|
// SortStringsDescending sorts a slice of strings in descending order in place.
|
|
func SortStringsDescending(data []string) {
|
|
sort.Sort(sort.Reverse(sort.StringSlice(data)))
|
|
}
|
|
|
|
// SortFloat64s sorts a slice of float64 values in ascending order in place.
|
|
func SortFloat64s(data []float64) {
|
|
sort.Float64s(data)
|
|
}
|
|
|
|
// SortFloat64sDescending sorts a slice of float64 values in descending order in place.
|
|
func SortFloat64sDescending(data []float64) {
|
|
sort.Sort(sort.Reverse(sort.Float64Slice(data)))
|
|
}
|
|
|
|
// SortBy sorts a slice using a custom less function.
|
|
// The less function should return true if data[i] should come before data[j].
|
|
func SortBy[T any](data []T, less func(i, j int) bool) {
|
|
sort.Slice(data, less)
|
|
}
|
|
|
|
// SortByKey sorts a slice by extracting a comparable key from each element.
|
|
// K is restricted to int, float64, or string.
|
|
func SortByKey[T any, K int | float64 | string](data []T, key func(T) K) {
|
|
sort.Slice(data, func(i, j int) bool {
|
|
return key(data[i]) < key(data[j])
|
|
})
|
|
}
|
|
|
|
// SortByKeyDescending sorts a slice by extracting a comparable key from each element in descending order.
|
|
func SortByKeyDescending[T any, K int | float64 | string](data []T, key func(T) K) {
|
|
sort.Slice(data, func(i, j int) bool {
|
|
return key(data[i]) > key(data[j])
|
|
})
|
|
}
|
|
|
|
// IsSorted checks if a slice of integers is sorted in ascending order.
|
|
func IsSorted(data []int) bool {
|
|
return sort.IntsAreSorted(data)
|
|
}
|
|
|
|
// IsSortedStrings checks if a slice of strings is sorted in ascending order.
|
|
func IsSortedStrings(data []string) bool {
|
|
return sort.StringsAreSorted(data)
|
|
}
|
|
|
|
// IsSortedFloat64s checks if a slice of float64 values is sorted in ascending order.
|
|
func IsSortedFloat64s(data []float64) bool {
|
|
return sort.Float64sAreSorted(data)
|
|
}
|
|
|
|
// BinarySearch performs a binary search on a sorted slice of integers.
|
|
// Returns the index where target is found, or -1 if not found.
|
|
func BinarySearch(data []int, target int) int {
|
|
idx := sort.SearchInts(data, target)
|
|
if idx < len(data) && data[idx] == target {
|
|
return idx
|
|
}
|
|
return -1
|
|
}
|
|
|
|
// BinarySearchStrings performs a binary search on a sorted slice of strings.
|
|
// Returns the index where target is found, or -1 if not found.
|
|
func BinarySearchStrings(data []string, target string) int {
|
|
idx := sort.SearchStrings(data, target)
|
|
if idx < len(data) && data[idx] == target {
|
|
return idx
|
|
}
|
|
return -1
|
|
}
|