Update README_EN.md

Author: yanglbme

solution/1500-1599/1550.Three Consecutive Odds/README_EN.md

@@ -51,7 +51,15 @@ Given an integer array <code>arr</code>, return <code>true</code>&nbsp;if there
 
 <!-- solution:start -->
 
-### Solution 1
+### Solution 1: Iteration + Counting
+
+We use a variable $\text{cnt}$ to record the current count of consecutive odd numbers.
+
+Next, we iterate through the array. If the current element is odd, then $\text{cnt}$ is incremented by one. If $\text{cnt}$ equals 3, then return $\text{True}$. If the current element is even, then $\text{cnt}$ is reset to zero.
+
+After the iteration, if three consecutive odd numbers are not found, then return $\text{False}$.
+
+The time complexity is $O(n)$, where $n$ is the length of the array $\text{arr}$. The space complexity is $O(1)$.
 
 <!-- tabs:start -->
 
@@ -61,13 +69,13 @@ Given an integer array <code>arr</code>, return <code>true</code>&nbsp;if there
 class Solution:
     def threeConsecutiveOdds(self, arr: List[int]) -> bool:
         cnt = 0
-        for v in arr:
-            if v & 1:
+        for x in arr:
+            if x & 1:
                 cnt += 1
+                if cnt == 3:
+                    return True
             else:
                 cnt = 0
-            if cnt == 3:
-                return True
         return False
 ```
 
@@ -77,15 +85,14 @@ class Solution:
 class Solution {
     public boolean threeConsecutiveOdds(int[] arr) {
         int cnt = 0;
-        for (int v : arr) {
-            if (v % 2 == 1) {
-                ++cnt;
+        for (int x : arr) {
+            if (x % 2 == 1) {
+                if (++cnt == 3) {
+                    return true;
+                }
             } else {
                 cnt = 0;
             }
-            if (cnt == 3) {
-                return true;
-            }
         }
         return false;
     }
@@ -99,12 +106,14 @@ class Solution {
 public:
     bool threeConsecutiveOdds(vector<int>& arr) {
         int cnt = 0;
-        for (int v : arr) {
-            if (v & 1)
-                ++cnt;
-            else
+        for (int x : arr) {
+            if (x & 1) {
+                if (++cnt == 3) {
+                    return true;
+                }
+            } else {
                 cnt = 0;
-            if (cnt == 3) return true;
+            }
         }
         return false;
     }
@@ -116,15 +125,15 @@ public:
 ```go
 func threeConsecutiveOdds(arr []int) bool {
 	cnt := 0
-	for _, v := range arr {
-		if v%2 == 1 {
+	for _, x := range arr {
+		if x&1 == 1 {
 			cnt++
+			if cnt == 3 {
+				return true
+			}
 		} else {
 			cnt = 0
 		}
-		if cnt == 3 {
-			return true
-		}
 	}
 	return false
 }
@@ -135,15 +144,14 @@ func threeConsecutiveOdds(arr []int) bool {
 ```ts
 function threeConsecutiveOdds(arr: number[]): boolean {
     let cnt = 0;
-    for (const v of arr) {
-        if (v & 1) {
-            ++cnt;
+    for (const x of arr) {
+        if (x & 1) {
+            if (++cnt == 3) {
+                return true;
+            }
         } else {
             cnt = 0;
         }
-        if (cnt == 3) {
-            return true;
-        }
     }
     return false;
 }
@@ -155,7 +163,13 @@ function threeConsecutiveOdds(arr: number[]): boolean {
 
 <!-- solution:start -->
 
-### Solution 2
+### Solution 2: Iteration + Bitwise Operation
+
+Based on the properties of bitwise operations, the result of a bitwise AND operation between two numbers is odd if and only if both numbers are odd. If there are three consecutive numbers whose bitwise AND result is odd, then these three numbers are all odd.
+
+Therefore, we only need to iterate through the array and check if there exists three consecutive numbers whose bitwise AND result is odd. If such numbers exist, return $\text{True}$; otherwise, return $\text{False}$.
+
+The time complexity is $O(n)$, where $n$ is the length of the array $\text{arr}$. The space complexity is $O(1)$.
 
 <!-- tabs:start -->
 
@@ -164,20 +178,59 @@ function threeConsecutiveOdds(arr: number[]): boolean {
 ```python
 class Solution:
     def threeConsecutiveOdds(self, arr: List[int]) -> bool:
-        for i in range(len(arr) - 2):
-            if arr[i] % 2 + arr[i + 1] % 2 + arr[i + 2] % 2 == 3:
-                return True
-        return False
+        return any(x & arr[i + 1] & arr[i + 2] & 1 for i, x in enumerate(arr[:-2]))
+```
+
+#### Java
+
+```java
+class Solution {
+    public boolean threeConsecutiveOdds(int[] arr) {
+        for (int i = 2, n = arr.length; i < n; ++i) {
+            if ((arr[i - 2] & arr[i - 1] & arr[i] & 1) == 1) {
+                return true;
+            }
+        }
+        return false;
+    }
+}
+```
+
+#### C++
+
+```cpp
+class Solution {
+public:
+    bool threeConsecutiveOdds(vector<int>& arr) {
+        for (int i = 2, n = arr.size(); i < n; ++i) {
+            if (arr[i - 2] & arr[i - 1] & arr[i] & 1) {
+                return true;
+            }
+        }
+        return false;
+    }
+};
+```
+
+#### Go
+
+```go
+func threeConsecutiveOdds(arr []int) bool {
+	for i, n := 2, len(arr); i < n; i++ {
+		if arr[i-2]&arr[i-1]&arr[i]&1 == 1 {
+			return true
+		}
+	}
+	return false
+}
 ```
 
 #### TypeScript
 
 ```ts
 function threeConsecutiveOdds(arr: number[]): boolean {
     const n = arr.length;
-    if (n < 3) return false;
-
-    for (let i = 2; i < n; i++) {
+    for (let i = 2; i < n; ++i) {
         if (arr[i - 2] & arr[i - 1] & arr[i] & 1) {
             return true;
         }