feat: add solutions to lc problem: No.2211

No.2211.Count Collisions on a Road

Author: yanglbme

solution/2200-2299/2211.Count Collisions on a Road/README.md

@@ -58,7 +58,9 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-这个题比较有意思，最后规律是左边向左的车辆可以出去，右边向右的车辆可以出去，中间不是 S 的都出不来。
+-   去除前缀为 `L` 的字符；
+-   去除后缀为 `R` 的字符；
+-   剩余的字符串中，除了 `S` 以外的字符，都会贡献一次碰撞次数。
 
 <!-- tabs:start -->
 
@@ -69,15 +71,8 @@
 ```python
 class Solution:
     def countCollisions(self, directions: str) -> int:
-        l, r = 0, len(directions)-1
-        while l <= r and directions[l] == 'L':
-            l += 1
-        while l <= r and directions[r] == 'R':
-            r -= 1
-        count = 0
-        for i in range(l, r+1):
-            count += directions[i] != 'S'
-        return count
+        d = directions.lstrip('L').rstrip('R')
+        return len(d) - d.count('S')
 ```
 
 ### **Java**
@@ -87,25 +82,48 @@ class Solution:
 ```java
 class Solution {
     public int countCollisions(String directions) {
-        int l = 0, r = directions.length() - 1, count = 0;
-        while (l <= r && directions.substring(l, l + 1).equals("L")) {
-            l++;
+        char[] ds = directions.toCharArray();
+        int n = ds.length;
+        int l = 0;
+        int r = n - 1;
+        while (l < n && ds[l] == 'L') {
+            ++l;
         }
-        while (l <= r && directions.substring(r, r + 1).equals("R")) {
-            r--;
+        while (r >= 0 && ds[r] == 'R') {
+            --r;
         }
-        for (int i = l; i <= r; i++) {
-            if (!directions.substring(i, i + 1).equals("S")) count += 1;
+        int ans = 0;
+        for (int i = l; i <= r; ++i) {
+            if (ds[i] != 'S') {
+                ++ans;
+            }
         }
-        return count;
+        return ans;
     }
 }
 ```
 
 ### **TypeScript**
 
 ```ts
-
+function countCollisions(directions: string): number {
+    const n = directions.length;
+    let l = 0,
+        r = n - 1;
+    while (l < n && directions[l] == 'L') {
+        ++l;
+    }
+    while (r >= 0 && directions[r] == 'R') {
+        --r;
+    }
+    let ans = 0;
+    for (let i = l; i <= r; ++i) {
+        if (directions[i] != 'S') {
+            ++ans;
+        }
+    }
+    return ans;
+}
 ```
 
 ### **C++**
@@ -130,4 +148,20 @@ public:
 };
 ```
 
+### **Go**
+
+```go
+func countCollisions(directions string) int {
+	d := strings.TrimLeft(directions, "L")
+	d = strings.TrimRight(d, "R")
+	return len(d) - strings.Count(d, "S")
+}
+```
+
+### **...**
+
+```
+
+```
+
 <!-- tabs:end -->

solution/2200-2299/2211.Count Collisions on a Road/README_EN.md

@@ -59,41 +59,57 @@ No cars will collide with each other. Thus, the total number of collisions that
 ```python
 class Solution:
     def countCollisions(self, directions: str) -> int:
-        l, r = 0, len(directions)-1
-        while l <= r and directions[l] == 'L':
-            l += 1
-        while l <= r and directions[r] == 'R':
-            r -= 1
-        count = 0
-        for i in range(l, r+1):
-            count += directions[i] != 'S'
-        return count
+        d = directions.lstrip('L').rstrip('R')
+        return len(d) - d.count('S')
 ```
 
 ### **Java**
 
 ```java
 class Solution {
     public int countCollisions(String directions) {
-        int l = 0, r = directions.length() - 1, count = 0;
-        while (l <= r && directions.substring(l, l + 1).equals("L")) {
-            l++;
+        char[] ds = directions.toCharArray();
+        int n = ds.length;
+        int l = 0;
+        int r = n - 1;
+        while (l < n && ds[l] == 'L') {
+            ++l;
         }
-        while (l <= r && directions.substring(r, r + 1).equals("R")) {
-            r--;
+        while (r >= 0 && ds[r] == 'R') {
+            --r;
         }
-        for (int i = l; i <= r; i++) {
-            if (!directions.substring(i, i + 1).equals("S")) count += 1;
+        int ans = 0;
+        for (int i = l; i <= r; ++i) {
+            if (ds[i] != 'S') {
+                ++ans;
+            }
         }
-        return count;
+        return ans;
     }
 }
 ```
 
 ### **TypeScript**
 
 ```ts
-
+function countCollisions(directions: string): number {
+    const n = directions.length;
+    let l = 0,
+        r = n - 1;
+    while (l < n && directions[l] == 'L') {
+        ++l;
+    }
+    while (r >= 0 && directions[r] == 'R') {
+        --r;
+    }
+    let ans = 0;
+    for (let i = l; i <= r; ++i) {
+        if (directions[i] != 'S') {
+            ++ans;
+        }
+    }
+    return ans;
+}
 ```
 
 ### **C++**
@@ -118,4 +134,20 @@ public:
 };
 ```
 
+### **Go**
+
+```go
+func countCollisions(directions string) int {
+	d := strings.TrimLeft(directions, "L")
+	d = strings.TrimRight(d, "R")
+	return len(d) - strings.Count(d, "S")
+}
+```
+
+### **...**
+
+```
+
+```
+
 <!-- tabs:end -->

solution/2200-2299/2211.Count Collisions on a Road/Solution.go

@@ -0,0 +1,5 @@
+func countCollisions(directions string) int {
+	d := strings.TrimLeft(directions, "L")
+	d = strings.TrimRight(d, "R")
+	return len(d) - strings.Count(d, "S")
+}

solution/2200-2299/2211.Count Collisions on a Road/Solution.java

@@ -1,15 +1,21 @@
 class Solution {
     public int countCollisions(String directions) {
-        int l = 0, r = directions.length() - 1, count = 0;
-        while (l <= r && directions.substring(l, l + 1).equals("L")) {
-            l++;
+        char[] ds = directions.toCharArray();
+        int n = ds.length;
+        int l = 0;
+        int r = n - 1;
+        while (l < n && ds[l] == 'L') {
+            ++l;
         }
-        while (l <= r && directions.substring(r, r + 1).equals("R")) {
-            r--;
+        while (r >= 0 && ds[r] == 'R') {
+            --r;
         }
-        for (int i = l; i <= r; i++) {
-            if (!directions.substring(i, i + 1).equals("S")) count += 1;
+        int ans = 0;
+        for (int i = l; i <= r; ++i) {
+            if (ds[i] != 'S') {
+                ++ans;
+            }
         }
-        return count;
+        return ans;
     }
-}
+}

solution/2200-2299/2211.Count Collisions on a Road/Solution.py

@@ -1,11 +1,4 @@
 class Solution:
     def countCollisions(self, directions: str) -> int:
-        l, r = 0, len(directions)-1
-        while l <= r and directions[l] == 'L':
-            l += 1
-        while l <= r and directions[r] == 'R':
-            r -= 1
-        count = 0
-        for i in range(l, r+1):
-            count += directions[i] != 'S'
-        return count
+        d = directions.lstrip('L').rstrip('R')
+        return len(d) - d.count('S')

solution/2200-2299/2211.Count Collisions on a Road/Solution.ts

@@ -0,0 +1,18 @@
+function countCollisions(directions: string): number {
+    const n = directions.length;
+    let l = 0,
+        r = n - 1;
+    while (l < n && directions[l] == 'L') {
+        ++l;
+    }
+    while (r >= 0 && directions[r] == 'R') {
+        --r;
+    }
+    let ans = 0;
+    for (let i = l; i <= r; ++i) {
+        if (directions[i] != 'S') {
+            ++ans;
+        }
+    }
+    return ans;
+}

solution/2200-2299/2213.Longest Substring of One Repeating Character/README.md

@@ -150,9 +150,7 @@ class SegmentTree:
             root.mx = max(root.mx, left.rmx + right.lmx)
 
     def pushup(self, u):
-        root = tr[u]
-        left, right = tr[u << 1], tr[u << 1 | 1]
-        self._pushup(root, left, right)
+        self._pushup(tr[u], tr[u << 1], tr[u << 1 | 1])
 
 
 class Solution:

solution/2200-2299/2213.Longest Substring of One Repeating Character/README_EN.md

@@ -129,9 +129,7 @@ class SegmentTree:
             root.mx = max(root.mx, left.rmx + right.lmx)
 
     def pushup(self, u):
-        root = tr[u]
-        left, right = tr[u << 1], tr[u << 1 | 1]
-        self._pushup(root, left, right)
+        self._pushup(tr[u], tr[u << 1], tr[u << 1 | 1])
 
 
 class Solution:

solution/2200-2299/2213.Longest Substring of One Repeating Character/Solution.py

@@ -71,9 +71,7 @@ def _pushup(self, root, left, right):
             root.mx = max(root.mx, left.rmx + right.lmx)
 
     def pushup(self, u):
-        root = tr[u]
-        left, right = tr[u << 1], tr[u << 1 | 1]
-        self._pushup(root, left, right)
+        self._pushup(tr[u], tr[u << 1], tr[u << 1 | 1])
 
 
 class Solution: