feat: add solutions to lc problem: No.3637 (#4618)

No.3637.Trionic Array I

Author: yanglbme

solution/3600-3699/3637.Trionic Array I/README.md

@@ -73,32 +73,146 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3600-3699/3637.Tr
 
 <!-- solution:start -->
 
-### 方法一
+### 方法一：一次遍历
+
+我们首先定义一个指针 $p$，初始时 $p = 0$，表示当前指向数组的第一个元素。我们将 $p$ 向右移动，直到找到第一个不满足严格递增的元素，即 $nums[p] \geq nums[p + 1]$。如果此时 $p = 0$，说明数组的前半部分没有严格递增的部分，因此直接返回 $\text{false}$。
+
+接下来，我们定义另一个指针 $q$，初始时 $q = p$，表示当前指向数组的第二个部分的第一个元素。我们将 $q$ 向右移动，直到找到第一个不满足严格递减的元素，即 $nums[q] \leq nums[q + 1]$。如果此时 $q = p$ 或者 $q = n - 1$，说明数组的第二部分没有严格递减的部分或者没有第三部分，因此直接返回 $\text{false}$。
+
+如果以上条件都满足，说明数组是三段式的，返回 $\text{true}$。
+
+时间复杂度 $O(n)$，其中 $n$ 是数组的长度。空间复杂度 $O(1)$，只使用了常数级别的额外空间。
 
 <!-- tabs:start -->
 
 #### Python3
 
 ```python
-
+class Solution:
+    def isTrionic(self, nums: List[int]) -> bool:
+        n = len(nums)
+        p = 0
+        while p < n - 2 and nums[p] < nums[p + 1]:
+            p += 1
+        if p == 0:
+            return False
+        q = p
+        while q < n - 1 and nums[q] > nums[q + 1]:
+            q += 1
+        if q == p or q == n - 1:
+            return False
+        while q < n - 1 and nums[q] < nums[q + 1]:
+            q += 1
+        return q == n - 1
 ```
 
 #### Java
 
 ```java
-
+class Solution {
+    public boolean isTrionic(int[] nums) {
+        int n = nums.length;
+        int p = 0;
+        while (p < n - 2 && nums[p] < nums[p + 1]) {
+            p++;
+        }
+        if (p == 0) {
+            return false;
+        }
+        int q = p;
+        while (q < n - 1 && nums[q] > nums[q + 1]) {
+            q++;
+        }
+        if (q == p || q == n - 1) {
+            return false;
+        }
+        while (q < n - 1 && nums[q] < nums[q + 1]) {
+            q++;
+        }
+        return q == n - 1;
+    }
+}
 ```
 
 #### C++
 
 ```cpp
-
+class Solution {
+public:
+    bool isTrionic(vector<int>& nums) {
+        int n = nums.size();
+        int p = 0;
+        while (p < n - 2 && nums[p] < nums[p + 1]) {
+            p++;
+        }
+        if (p == 0) {
+            return false;
+        }
+        int q = p;
+        while (q < n - 1 && nums[q] > nums[q + 1]) {
+            q++;
+        }
+        if (q == p || q == n - 1) {
+            return false;
+        }
+        while (q < n - 1 && nums[q] < nums[q + 1]) {
+            q++;
+        }
+        return q == n - 1;
+    }
+};
 ```
 
 #### Go
 
 ```go
+func isTrionic(nums []int) bool {
+	n := len(nums)
+	p := 0
+	for p < n-2 && nums[p] < nums[p+1] {
+		p++
+	}
+	if p == 0 {
+		return false
+	}
+	q := p
+	for q < n-1 && nums[q] > nums[q+1] {
+		q++
+	}
+	if q == p || q == n-1 {
+		return false
+	}
+	for q < n-1 && nums[q] < nums[q+1] {
+		q++
+	}
+	return q == n-1
+}
+```
 
+#### TypeScript
+
+```ts
+function isTrionic(nums: number[]): boolean {
+    const n = nums.length;
+    let p = 0;
+    while (p < n - 2 && nums[p] < nums[p + 1]) {
+        p++;
+    }
+    if (p === 0) {
+        return false;
+    }
+    let q = p;
+    while (q < n - 1 && nums[q] > nums[q + 1]) {
+        q++;
+    }
+    if (q === p || q === n - 1) {
+        return false;
+    }
+    while (q < n - 1 && nums[q] < nums[q + 1]) {
+        q++;
+    }
+    return q === n - 1;
+}
 ```
 
 <!-- tabs:end -->

solution/3600-3699/3637.Trionic Array I/README_EN.md

@@ -71,32 +71,146 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3600-3699/3637.Tr
 
 <!-- solution:start -->
 
-### Solution 1
+### Solution 1: Single Pass
+
+We first define a pointer $p$, initially $p = 0$, pointing to the first element of the array. We move $p$ to the right until we find the first element that doesn't satisfy strict increasing order, i.e., $nums[p] \geq nums[p + 1]$. If $p = 0$ at this point, it means the first part of the array doesn't have a strictly increasing section, so we return $\text{false}$ directly.
+
+Next, we define another pointer $q$, initially $q = p$, pointing to the first element of the second part of the array. We move $q$ to the right until we find the first element that doesn't satisfy strict decreasing order, i.e., $nums[q] \leq nums[q + 1]$. If $q = p$ or $q = n - 1$ at this point, it means the second part of the array doesn't have a strictly decreasing section or there's no third part, so we return $\text{false}$ directly.
+
+If all the above conditions are satisfied, it means the array is trionic, and we return $\text{true}$.
+
+The time complexity is $O(n)$, where $n$ is the length of the array. The space complexity is $O(1)$, using only constant extra space.
 
 <!-- tabs:start -->
 
 #### Python3
 
 ```python
-
+class Solution:
+    def isTrionic(self, nums: List[int]) -> bool:
+        n = len(nums)
+        p = 0
+        while p < n - 2 and nums[p] < nums[p + 1]:
+            p += 1
+        if p == 0:
+            return False
+        q = p
+        while q < n - 1 and nums[q] > nums[q + 1]:
+            q += 1
+        if q == p or q == n - 1:
+            return False
+        while q < n - 1 and nums[q] < nums[q + 1]:
+            q += 1
+        return q == n - 1
 ```
 
 #### Java
 
 ```java
-
+class Solution {
+    public boolean isTrionic(int[] nums) {
+        int n = nums.length;
+        int p = 0;
+        while (p < n - 2 && nums[p] < nums[p + 1]) {
+            p++;
+        }
+        if (p == 0) {
+            return false;
+        }
+        int q = p;
+        while (q < n - 1 && nums[q] > nums[q + 1]) {
+            q++;
+        }
+        if (q == p || q == n - 1) {
+            return false;
+        }
+        while (q < n - 1 && nums[q] < nums[q + 1]) {
+            q++;
+        }
+        return q == n - 1;
+    }
+}
 ```
 
 #### C++
 
 ```cpp
-
+class Solution {
+public:
+    bool isTrionic(vector<int>& nums) {
+        int n = nums.size();
+        int p = 0;
+        while (p < n - 2 && nums[p] < nums[p + 1]) {
+            p++;
+        }
+        if (p == 0) {
+            return false;
+        }
+        int q = p;
+        while (q < n - 1 && nums[q] > nums[q + 1]) {
+            q++;
+        }
+        if (q == p || q == n - 1) {
+            return false;
+        }
+        while (q < n - 1 && nums[q] < nums[q + 1]) {
+            q++;
+        }
+        return q == n - 1;
+    }
+};
 ```
 
 #### Go
 
 ```go
+func isTrionic(nums []int) bool {
+	n := len(nums)
+	p := 0
+	for p < n-2 && nums[p] < nums[p+1] {
+		p++
+	}
+	if p == 0 {
+		return false
+	}
+	q := p
+	for q < n-1 && nums[q] > nums[q+1] {
+		q++
+	}
+	if q == p || q == n-1 {
+		return false
+	}
+	for q < n-1 && nums[q] < nums[q+1] {
+		q++
+	}
+	return q == n-1
+}
+```
 
+#### TypeScript
+
+```ts
+function isTrionic(nums: number[]): boolean {
+    const n = nums.length;
+    let p = 0;
+    while (p < n - 2 && nums[p] < nums[p + 1]) {
+        p++;
+    }
+    if (p === 0) {
+        return false;
+    }
+    let q = p;
+    while (q < n - 1 && nums[q] > nums[q + 1]) {
+        q++;
+    }
+    if (q === p || q === n - 1) {
+        return false;
+    }
+    while (q < n - 1 && nums[q] < nums[q + 1]) {
+        q++;
+    }
+    return q === n - 1;
+}
 ```
 
 <!-- tabs:end -->

solution/3600-3699/3637.Trionic Array I/Solution.cpp

@@ -0,0 +1,24 @@
+class Solution {
+public:
+    bool isTrionic(vector<int>& nums) {
+        int n = nums.size();
+        int p = 0;
+        while (p < n - 2 && nums[p] < nums[p + 1]) {
+            p++;
+        }
+        if (p == 0) {
+            return false;
+        }
+        int q = p;
+        while (q < n - 1 && nums[q] > nums[q + 1]) {
+            q++;
+        }
+        if (q == p || q == n - 1) {
+            return false;
+        }
+        while (q < n - 1 && nums[q] < nums[q + 1]) {
+            q++;
+        }
+        return q == n - 1;
+    }
+};

solution/3600-3699/3637.Trionic Array I/Solution.go

@@ -0,0 +1,21 @@
+func isTrionic(nums []int) bool {
+	n := len(nums)
+	p := 0
+	for p < n-2 && nums[p] < nums[p+1] {
+		p++
+	}
+	if p == 0 {
+		return false
+	}
+	q := p
+	for q < n-1 && nums[q] > nums[q+1] {
+		q++
+	}
+	if q == p || q == n-1 {
+		return false
+	}
+	for q < n-1 && nums[q] < nums[q+1] {
+		q++
+	}
+	return q == n-1
+}

solution/3600-3699/3637.Trionic Array I/Solution.java

@@ -0,0 +1,23 @@
+class Solution {
+    public boolean isTrionic(int[] nums) {
+        int n = nums.length;
+        int p = 0;
+        while (p < n - 2 && nums[p] < nums[p + 1]) {
+            p++;
+        }
+        if (p == 0) {
+            return false;
+        }
+        int q = p;
+        while (q < n - 1 && nums[q] > nums[q + 1]) {
+            q++;
+        }
+        if (q == p || q == n - 1) {
+            return false;
+        }
+        while (q < n - 1 && nums[q] < nums[q + 1]) {
+            q++;
+        }
+        return q == n - 1;
+    }
+}

solution/3600-3699/3637.Trionic Array I/Solution.py

@@ -0,0 +1,16 @@
+class Solution:
+    def isTrionic(self, nums: List[int]) -> bool:
+        n = len(nums)
+        p = 0
+        while p < n - 2 and nums[p] < nums[p + 1]:
+            p += 1
+        if p == 0:
+            return False
+        q = p
+        while q < n - 1 and nums[q] > nums[q + 1]:
+            q += 1
+        if q == p or q == n - 1:
+            return False
+        while q < n - 1 and nums[q] < nums[q + 1]:
+            q += 1
+        return q == n - 1