From a7e77fa98d3d010761a94fd300370a292c591ef8 Mon Sep 17 00:00:00 2001
From: dudaodong <lanliddd.2007@163.com>
Date: Thu, 9 Feb 2023 19:30:11 +0800
Subject: [PATCH] feat: add IsSorted

---
 slice/slice.go              | 10 ++++++++--
 slice/slice_example_test.go | 24 ++++++++++++++++++++----
 slice/slice_test.go         | 18 +++++++++++++-----
 3 files changed, 41 insertions(+), 11 deletions(-)

diff --git a/slice/slice.go b/slice/slice.go
index 4f9c662..af97e77 100644
--- a/slice/slice.go
+++ b/slice/slice.go
@@ -842,9 +842,9 @@ func IsAscending[T constraints.Ordered](slice []T) bool {
 	return true
 }
 
-// Isdescending checks if a slice is descending order.
+// IsDescending checks if a slice is descending order.
 // Play: todo
-func Isdescending[T constraints.Ordered](slice []T) bool {
+func IsDescending[T constraints.Ordered](slice []T) bool {
 	for i := 1; i < len(slice); i++ {
 		if slice[i-1] < slice[i] {
 			return false
@@ -854,6 +854,12 @@ func Isdescending[T constraints.Ordered](slice []T) bool {
 	return true
 }
 
+// IsSorted checks if a slice is sorted(ascending or descending).
+// Play: todo
+func IsSorted[T constraints.Ordered](slice []T) bool {
+	return IsAscending(slice) || IsDescending(slice)
+}
+
 // Sort sorts a slice of any ordered type(number or string), use quick sort algrithm.
 // default sort order is ascending (asc), if want descending order, set param `sortOrder` to `desc`.
 // Play: https://go.dev/play/p/V9AVjzf_4Fk
diff --git a/slice/slice_example_test.go b/slice/slice_example_test.go
index 87498c9..73afbd9 100644
--- a/slice/slice_example_test.go
+++ b/slice/slice_example_test.go
@@ -701,11 +701,11 @@ func ExampleIsAscending() {
 	// false
 }
 
-func ExampleIsdescending() {
+func ExampleIsDescending() {
 
-	result1 := Isdescending([]int{5, 4, 3, 2, 1})
-	result2 := Isdescending([]int{1, 2, 3, 4, 5})
-	result3 := Isdescending([]int{2, 1, 3, 4, 5})
+	result1 := IsDescending([]int{5, 4, 3, 2, 1})
+	result2 := IsDescending([]int{1, 2, 3, 4, 5})
+	result3 := IsDescending([]int{2, 1, 3, 4, 5})
 
 	fmt.Println(result1)
 	fmt.Println(result2)
@@ -717,6 +717,22 @@ func ExampleIsdescending() {
 	// false
 }
 
+func ExampleIsSorted() {
+
+	result1 := IsSorted([]int{1, 2, 3, 4, 5})
+	result2 := IsSorted([]int{5, 4, 3, 2, 1})
+	result3 := IsSorted([]int{2, 1, 3, 4, 5})
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	fmt.Println(result3)
+
+	// Output:
+	// true
+	// true
+	// false
+}
+
 func ExampleSort() {
 	nums := []int{1, 4, 3, 2, 5}
 
diff --git a/slice/slice_test.go b/slice/slice_test.go
index d911464..8c72eb1 100644
--- a/slice/slice_test.go
+++ b/slice/slice_test.go
@@ -611,12 +611,20 @@ func TestIsAscending(t *testing.T) {
 	assert.Equal(false, IsAscending([]int{2, 1, 3, 4, 5}))
 }
 
-func TestIsdescending(t *testing.T) {
-	assert := internal.NewAssert(t, "TestIsdescending")
+func TestIsDescending(t *testing.T) {
+	assert := internal.NewAssert(t, "TestIsDescending")
 
-	assert.Equal(true, Isdescending([]int{5, 4, 3, 2, 1}))
-	assert.Equal(false, Isdescending([]int{1, 2, 3, 4, 5}))
-	assert.Equal(false, Isdescending([]int{2, 1, 3, 4, 5}))
+	assert.Equal(true, IsDescending([]int{5, 4, 3, 2, 1}))
+	assert.Equal(false, IsDescending([]int{1, 2, 3, 4, 5}))
+	assert.Equal(false, IsDescending([]int{2, 1, 3, 4, 5}))
+}
+
+func TestIsSorted(t *testing.T) {
+	assert := internal.NewAssert(t, "TestIsSorted")
+
+	assert.Equal(true, IsSorted([]int{5, 4, 3, 2, 1}))
+	assert.Equal(true, IsSorted([]int{1, 2, 3, 4, 5}))
+	assert.Equal(false, IsSorted([]int{2, 1, 3, 4, 5}))
 }
 
 func TestSort(t *testing.T) {