feat: add solutions to lc problem: No.0628, No.0665

Author: thinkasany

solution/0600-0699/0628.Maximum Product of Three Numbers/README.md

@@ -221,6 +221,48 @@ func max(a, b int) int {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function maximumProduct(nums: number[]): number {
+    nums.sort((a, b) => a - b);
+    const n = nums.length;
+    const a = nums[n - 1] * nums[n - 2] * nums[n - 3];
+    const b = nums[n - 1] * nums[0] * nums[1];
+    return Math.max(a, b);
+}
+```
+
+```ts
+function maximumProduct(nums: number[]): number {
+    const inf = 1 << 30;
+    let mi1 = inf,
+        mi2 = inf;
+    let mx1 = -inf,
+        mx2 = -inf,
+        mx3 = -inf;
+    for (const x of nums) {
+        if (x < mi1) {
+            mi2 = mi1;
+            mi1 = x;
+        } else if (x < mi2) {
+            mi2 = x;
+        }
+        if (x > mx1) {
+            mx3 = mx2;
+            mx2 = mx1;
+            mx1 = x;
+        } else if (x > mx2) {
+            mx3 = mx2;
+            mx2 = x;
+        } else if (x > mx3) {
+            mx3 = x;
+        }
+    }
+    return Math.max(mi1 * mi2 * mx1, mx1 * mx2 * mx3);
+}
+```
+
 ### **...**
 
 ```

solution/0600-0699/0628.Maximum Product of Three Numbers/README_EN.md

@@ -181,6 +181,48 @@ func max(a, b int) int {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function maximumProduct(nums: number[]): number {
+    nums.sort((a, b) => a - b);
+    const n = nums.length;
+    const a = nums[n - 1] * nums[n - 2] * nums[n - 3];
+    const b = nums[n - 1] * nums[0] * nums[1];
+    return Math.max(a, b);
+}
+```
+
+```ts
+function maximumProduct(nums: number[]): number {
+    const inf = 1 << 30;
+    let mi1 = inf,
+        mi2 = inf;
+    let mx1 = -inf,
+        mx2 = -inf,
+        mx3 = -inf;
+    for (const x of nums) {
+        if (x < mi1) {
+            mi2 = mi1;
+            mi1 = x;
+        } else if (x < mi2) {
+            mi2 = x;
+        }
+        if (x > mx1) {
+            mx3 = mx2;
+            mx2 = mx1;
+            mx1 = x;
+        } else if (x > mx2) {
+            mx3 = mx2;
+            mx2 = x;
+        } else if (x > mx3) {
+            mx3 = x;
+        }
+    }
+    return Math.max(mi1 * mi2 * mx1, mx1 * mx2 * mx3);
+}
+```
+
 ### **...**
 
 ```

solution/0600-0699/0628.Maximum Product of Three Numbers/Solution.ts

@@ -0,0 +1,27 @@
+function maximumProduct(nums: number[]): number {
+    const inf = 1 << 30;
+    let mi1 = inf,
+        mi2 = inf;
+    let mx1 = -inf,
+        mx2 = -inf,
+        mx3 = -inf;
+    for (const x of nums) {
+        if (x < mi1) {
+            mi2 = mi1;
+            mi1 = x;
+        } else if (x < mi2) {
+            mi2 = x;
+        }
+        if (x > mx1) {
+            mx3 = mx2;
+            mx2 = mx1;
+            mx1 = x;
+        } else if (x > mx2) {
+            mx3 = mx2;
+            mx2 = x;
+        } else if (x > mx3) {
+            mx3 = x;
+        }
+    }
+    return Math.max(mi1 * mi2 * mx1, mx1 * mx2 * mx3);
+}

solution/0600-0699/0665.Non-decreasing Array/README.md

@@ -162,6 +162,35 @@ func checkPossibility(nums []int) bool {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function checkPossibility(nums: number[]): boolean {
+    const isSorted = (nums: number[]) => {
+        for (let i = 0; i < nums.length - 1; ++i) {
+            if (nums[i] > nums[i + 1]) {
+                return false;
+            }
+        }
+        return true;
+    };
+    for (let i = 0; i < nums.length - 1; ++i) {
+        const a = nums[i],
+            b = nums[i + 1];
+        if (a > b) {
+            nums[i] = b;
+            if (isSorted(nums)) {
+                return true;
+            }
+            nums[i] = a;
+            nums[i + 1] = a;
+            return isSorted(nums);
+        }
+    }
+    return true;
+}
+```
+
 ### **...**
 
 ```

solution/0600-0699/0665.Non-decreasing Array/README_EN.md

@@ -141,6 +141,35 @@ func checkPossibility(nums []int) bool {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function checkPossibility(nums: number[]): boolean {
+    const isSorted = (nums: number[]) => {
+        for (let i = 0; i < nums.length - 1; ++i) {
+            if (nums[i] > nums[i + 1]) {
+                return false;
+            }
+        }
+        return true;
+    };
+    for (let i = 0; i < nums.length - 1; ++i) {
+        const a = nums[i],
+            b = nums[i + 1];
+        if (a > b) {
+            nums[i] = b;
+            if (isSorted(nums)) {
+                return true;
+            }
+            nums[i] = a;
+            nums[i + 1] = a;
+            return isSorted(nums);
+        }
+    }
+    return true;
+}
+```
+
 ### **...**
 
 ```

solution/0600-0699/0665.Non-decreasing Array/Solution.ts

@@ -0,0 +1,24 @@
+function checkPossibility(nums: number[]): boolean {
+    const isSorted = (nums: number[]) => {
+        for (let i = 0; i < nums.length - 1; ++i) {
+            if (nums[i] > nums[i + 1]) {
+                return false;
+            }
+        }
+        return true;
+    };
+    for (let i = 0; i < nums.length - 1; ++i) {
+        const a = nums[i],
+            b = nums[i + 1];
+        if (a > b) {
+            nums[i] = b;
+            if (isSorted(nums)) {
+                return true;
+            }
+            nums[i] = a;
+            nums[i + 1] = a;
+            return isSorted(nums);
+        }
+    }
+    return true;
+}