How do I partition a slice of strings in Go?

In Go, partitioning a slice of strings can be useful for various applications, such as categorizing strings based on specific criteria. Below is an example of how to partition a slice of strings into two separate slices based on a defined condition.

func partitionStrings(strings []string, predicate func(string) bool) ([]string, []string) { var trueSlice, falseSlice []string for _, str := range strings { if predicate(str) { trueSlice = append(trueSlice, str) } else { falseSlice = append(falseSlice, str) } } return trueSlice, falseSlice } func main() { fruits := []string{"apple", "banana", "cherry", "date", "elderberry"} isLongerThanFive := func(s string) bool { return len(s) > 5 } longFruits, shortFruits := partitionStrings(fruits, isLongerThanFive) fmt.Println("Fruits longer than 5 characters:", longFruits) fmt.Println("Fruits 5 characters or shorter:", shortFruits) }

go partition slice strings example code

Related Questions

How do I avoid rehashing overhead with std::set in multithreaded code?

How do I find elements with custom comparators with std::set for embedded targets?

How do I erase elements while iterating with std::set for embedded targets?

How do I provide stable iteration order with std::unordered_map for large datasets?

How do I reserve capacity ahead of time with std::unordered_map for large datasets?

How do I erase elements while iterating with std::unordered_map in multithreaded code?

How do I provide stable iteration order with std::map for embedded targets?

How do I provide stable iteration order with std::map in multithreaded code?

How do I avoid rehashing overhead with std::map in performance-sensitive code?

How do I merge two containers efficiently with std::map for embedded targets?