feat: update solutions to lc problem: No.0238

No.0238.Product of Array Except Self

Author: yanglbme

solution/0200-0299/0237.Delete Node in a Linked List/README.md

@@ -42,6 +42,8 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：节点赋值**
+
 将 `node.next` 节点的值赋给 `node`，然后将 `node.next` 指向 `node.next` 的下一个节点。
 
 <!-- tabs:start -->

solution/0200-0299/0238.Product of Array Except Self/README.md

@@ -196,29 +196,19 @@ function productExceptSelf(nums: number[]): number[] {
 
 ### **Go**
 
-利用前缀和思想，分别求出 `i` 左右两侧的乘积
-
 ```go
 func productExceptSelf(nums []int) []int {
 	n := len(nums)
-
-	l := make([]int, n)
-	l[0] = 1
-	for i := 1; i < n; i++ {
-		l[i] = l[i-1] * nums[i-1]
-	}
-
-	r := make([]int, n)
-	r[n-1] = 1
-	for i := n - 2; i >= 0; i-- {
-		r[i] = r[i+1] * nums[i+1]
-	}
-
 	ans := make([]int, n)
+	left, right := 1, 1
 	for i := 0; i < n; i++ {
-		ans[i] = l[i] * r[i]
+		ans[i] = left
+		left *= nums[i]
+	}
+	for i := n - 1; i >= 0; i-- {
+		ans[i] *= right
+		right *= nums[i]
 	}
-
 	return ans
 }
 ```

solution/0200-0299/0238.Product of Array Except Self/README_EN.md

@@ -124,24 +124,16 @@ function productExceptSelf(nums: number[]): number[] {
 ```go
 func productExceptSelf(nums []int) []int {
 	n := len(nums)
-
-	l := make([]int, n)
-	l[0] = 1
-	for i := 1; i < n; i++ {
-		l[i] = l[i-1] * nums[i-1]
-	}
-
-	r := make([]int, n)
-	r[n-1] = 1
-	for i := n - 2; i >= 0; i-- {
-		r[i] = r[i+1] * nums[i+1]
-	}
-
 	ans := make([]int, n)
+	left, right := 1, 1
 	for i := 0; i < n; i++ {
-		ans[i] = l[i] * r[i]
+		ans[i] = left
+		left *= nums[i]
+	}
+	for i := n - 1; i >= 0; i-- {
+		ans[i] *= right
+		right *= nums[i]
 	}
-
 	return ans
 }
 ```

solution/0200-0299/0238.Product of Array Except Self/Solution.go

@@ -1,22 +1,14 @@
 func productExceptSelf(nums []int) []int {
 	n := len(nums)
-
-	l := make([]int, n)
-	l[0] = 1
-	for i := 1; i < n; i++ {
-		l[i] = l[i-1] * nums[i-1]
-	}
-
-	r := make([]int, n)
-	r[n-1] = 1
-	for i := n - 2; i >= 0; i-- {
-		r[i] = r[i+1] * nums[i+1]
-	}
-
 	ans := make([]int, n)
+	left, right := 1, 1
 	for i := 0; i < n; i++ {
-		ans[i] = l[i] * r[i]
+		ans[i] = left
+		left *= nums[i]
+	}
+	for i := n - 1; i >= 0; i-- {
+		ans[i] *= right
+		right *= nums[i]
 	}
-
 	return ans
-}
+}

solution/0200-0299/0292.Nim Game/README.md

@@ -57,15 +57,19 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-第一个得到 4 的倍数（即 n % 4 == 0）的将会输掉比赛。
+**方法一：数学推理**
+
+第一个得到 $4$ 的倍数（即 $n$ 能被 $4$ 整除）的将会输掉比赛。
 
 证明：
 
-1. 当 `n == 4`，无论第一个玩家选择 1/2/3 哪个数字，第二个玩家总能选择剩下的数字，**第一个玩家将会输掉比赛**。
-1. 当 `4 < n < 8`，即 (n = 5,6,7)，第一个玩家可以相应地将数字减少为 4，那么 4 这个死亡数字给到了第二个玩家，第二个玩家将会输掉比赛。
-1. 当 `n == 8`，无论第一个玩家选择 1/2/3 哪个数字，都会把 `4 < n < 8` 的数字留给第二个，**第一个玩家将会输掉比赛**。
+1. 当 $n=4$，无论第一个玩家选择 $1/2/3$ 哪个数字，第二个玩家总能选择剩下的数字，**第一个玩家将会输掉比赛**。
+1. 当 $4<n<8$，即 ($n=5,6,7$)，第一个玩家可以相应地将数字减少为 $4$，那么 $4$ 这个死亡数字给到了第二个玩家，第二个玩家将会输掉比赛。
+1. 当 $n=8$，无论第一个玩家选择 $1/2/3$ 哪个数字，都会把 $4<n<8$ 的数字留给第二个，**第一个玩家将会输掉比赛**。
 1. ...
-1. 依次类推，当玩家拿到 n 这个数字，且 n 能被 4 整除，即 `n % 4 == 0`，他将会输掉比赛，否则他将赢得比赛。
+1. 依次类推，当玩家拿到 $n$ 这个数字，且 $n$ 能被 $4$ 整除，他将会输掉比赛，否则他将赢得比赛。
+
+时间复杂度 $O(1)$。
 
 <!-- tabs:start -->