feat: add solutions for lc No.2751 (#5112)

Author: yanglbme

solution/2700-2799/2751.Robot Collisions/README.md

@@ -2,44 +2,45 @@ class Solution {
 public:
     vector<int> survivedRobotsHealths(vector<int>& positions, vector<int>& healths, string directions) {
         int n = positions.size();
-        vector<int> indices(n);
+        vector<int> idx(n);
+        iota(idx.begin(), idx.end(), 0);
 
-        iota(indices.begin(), indices.end(), 0);
-        stack<int> st;
+        sort(idx.begin(), idx.end(), [&](int a, int b) {
+            return positions[a] < positions[b];
+        });
 
-        auto lambda = [&](int i, int j) { return positions[i] < positions[j]; };
+        vector<int> stk;
 
-        sort(begin(indices), end(indices), lambda);
+        for (int i : idx) {
+            if (directions[i] == 'R') {
+                stk.push_back(i);
+                continue;
+            }
 
-        vector<int> result;
-        for (int currentIndex : indices) {
-            if (directions[currentIndex] == 'R') {
-                st.push(currentIndex);
-            } else {
-                while (!st.empty() && healths[currentIndex] > 0) {
-                    int topIndex = st.top();
-                    st.pop();
+            while (!stk.empty() && healths[i] > 0) {
+                int j = stk.back();
 
-                    if (healths[topIndex] > healths[currentIndex]) {
-                        healths[topIndex] -= 1;
-                        healths[currentIndex] = 0;
-                        st.push(topIndex);
-                    } else if (healths[topIndex] < healths[currentIndex]) {
-                        healths[currentIndex] -= 1;
-                        healths[topIndex] = 0;
-                    } else {
-                        healths[currentIndex] = 0;
-                        healths[topIndex] = 0;
-                    }
+                if (healths[j] > healths[i]) {
+                    healths[j]--;
+                    healths[i] = 0;
+                } else if (healths[j] < healths[i]) {
+                    healths[i]--;
+                    healths[j] = 0;
+                    stk.pop_back();
+                } else {
+                    healths[i] = healths[j] = 0;
+                    stk.pop_back();
+                    break;
                 }
             }
         }
 
-        for (int i = 0; i < n; ++i) {
-            if (healths[i] > 0) {
-                result.push_back(healths[i]);
+        vector<int> ans;
+        for (int h : healths) {
+            if (h > 0) {
+                ans.push_back(h);
             }
         }
-        return result;
+        return ans;
     }
 };

solution/2700-2799/2751.Robot Collisions/README_EN.md

@@ -1,45 +1,45 @@
 func survivedRobotsHealths(positions []int, healths []int, directions string) []int {
 	n := len(positions)
-	indices := make([]int, n)
-	for i := range indices {
-		indices[i] = i
+	idx := make([]int, n)
+	for i := range idx {
+		idx[i] = i
 	}
 
-	sort.Slice(indices, func(i, j int) bool {
-		return positions[indices[i]] < positions[indices[j]]
+	sort.Slice(idx, func(i, j int) bool {
+		return positions[idx[i]] < positions[idx[j]]
 	})
 
-	stack := []int{}
+	stk := []int{}
 
-	for _, currentIndex := range indices {
-		if directions[currentIndex] == 'R' {
-			stack = append(stack, currentIndex)
-		} else {
-			for len(stack) > 0 && healths[currentIndex] > 0 {
-				topIndex := stack[len(stack)-1]
-				stack = stack[:len(stack)-1]
+	for _, i := range idx {
+		if directions[i] == 'R' {
+			stk = append(stk, i)
+			continue
+		}
+
+		for len(stk) > 0 && healths[i] > 0 {
+			j := stk[len(stk)-1]
 
-				if healths[topIndex] > healths[currentIndex] {
-					healths[topIndex] -= 1
-					healths[currentIndex] = 0
-					stack = append(stack, topIndex)
-				} else if healths[topIndex] < healths[currentIndex] {
-					healths[currentIndex] -= 1
-					healths[topIndex] = 0
-				} else {
-					healths[currentIndex] = 0
-					healths[topIndex] = 0
-				}
+			if healths[j] > healths[i] {
+				healths[j]--
+				healths[i] = 0
+			} else if healths[j] < healths[i] {
+				healths[i]--
+				healths[j] = 0
+				stk = stk[:len(stk)-1]
+			} else {
+				healths[i], healths[j] = 0, 0
+				stk = stk[:len(stk)-1]
+				break
 			}
 		}
 	}
 
-	result := []int{}
-	for _, health := range healths {
-		if health > 0 {
-			result = append(result, health)
+	ans := []int{}
+	for _, h := range healths {
+		if h > 0 {
+			ans = append(ans, h)
 		}
 	}
-
-	return result
-}
+	return ans
+}

solution/2700-2799/2751.Robot Collisions/Solution.cpp

@@ -1,44 +1,42 @@
 class Solution {
     public List<Integer> survivedRobotsHealths(int[] positions, int[] healths, String directions) {
         int n = positions.length;
-        Integer[] indices = new Integer[n];
-        for (int i = 0; i < n; i++) {
-            indices[i] = i;
-        }
+        Integer[] idx = new Integer[n];
+        Arrays.setAll(idx, i -> i);
+        Arrays.sort(idx, (a, b) -> positions[a] - positions[b]);
 
-        Arrays.sort(indices, (i, j) -> Integer.compare(positions[i], positions[j]));
+        Deque<Integer> stk = new ArrayDeque<>();
 
-        Stack<Integer> stack = new Stack<>();
+        for (int i : idx) {
+            if (directions.charAt(i) == 'R') {
+                stk.push(i);
+                continue;
+            }
 
-        for (int currentIndex : indices) {
-            if (directions.charAt(currentIndex) == 'R') {
-                stack.push(currentIndex);
-            } else {
-                while (!stack.isEmpty() && healths[currentIndex] > 0) {
-                    int topIndex = stack.pop();
+            while (!stk.isEmpty() && healths[i] > 0) {
+                int j = stk.peek();
 
-                    if (healths[topIndex] > healths[currentIndex]) {
-                        healths[topIndex] -= 1;
-                        healths[currentIndex] = 0;
-                        stack.push(topIndex);
-                    } else if (healths[topIndex] < healths[currentIndex]) {
-                        healths[currentIndex] -= 1;
-                        healths[topIndex] = 0;
-                    } else {
-                        healths[currentIndex] = 0;
-                        healths[topIndex] = 0;
-                    }
+                if (healths[j] > healths[i]) {
+                    healths[j]--;
+                    healths[i] = 0;
+                } else if (healths[j] < healths[i]) {
+                    healths[i]--;
+                    healths[j] = 0;
+                    stk.pop();
+                } else {
+                    healths[i] = healths[j] = 0;
+                    stk.pop();
+                    break;
                 }
             }
         }
 
-        List<Integer> result = new ArrayList<>();
-        for (int health : healths) {
-            if (health > 0) {
-                result.add(health);
+        List<Integer> ans = new ArrayList<>();
+        for (int h : healths) {
+            if (h > 0) {
+                ans.add(h);
             }
         }
-
-        return result;
+        return ans;
     }
-}
+}

solution/2700-2799/2751.Robot Collisions/Solution.go

@@ -5,36 +5,34 @@
  * @return {number[]}
  */
 var survivedRobotsHealths = function (positions, healths, directions) {
-    const idx = Array.from({ length: positions.length }, (_, i) => i);
-    const stk = [];
+    const n = positions.length;
+    const idx = Array.from({ length: n }, (_, i) => i).sort((a, b) => positions[a] - positions[b]);
 
-    idx.sort((a, b) => positions[a] - positions[b]);
+    const stk = [];
 
-    for (let iRight of idx) {
-        while (stk.length) {
-            const iLeft = stk.at(-1);
-            const havePair = directions[iLeft] === 'R' && directions[iRight] === 'L';
-            if (!havePair) break;
+    for (const i of idx) {
+        if (directions[i] === 'R') {
+            stk.push(i);
+            continue;
+        }
 
-            if (healths[iLeft] === healths[iRight]) {
-                healths[iLeft] = healths[iRight] = iRight = -1;
-                stk.pop();
-                break;
-            }
+        while (stk.length && healths[i] > 0) {
+            const j = stk[stk.length - 1];
 
-            if (healths[iLeft] < healths[iRight]) {
-                healths[iLeft] = -1;
-                healths[iRight]--;
+            if (healths[j] > healths[i]) {
+                healths[j]--;
+                healths[i] = 0;
+            } else if (healths[j] < healths[i]) {
+                healths[i]--;
+                healths[j] = 0;
                 stk.pop();
             } else {
-                healths[iRight] = iRight = -1;
-                healths[iLeft]--;
+                healths[i] = healths[j] = 0;
+                stk.pop();
                 break;
             }
         }
-
-        if (iRight !== -1) stk.push(iRight);
     }
 
-    return healths.filter(i => ~i);
+    return healths.filter(h => h > 0);
 };

solution/2700-2799/2751.Robot Collisions/Solution.java

@@ -1,30 +1,25 @@
 class Solution:
-    def survivedRobotsHealths(
-        self, positions: List[int], healths: List[int], directions: str
-    ) -> List[int]:
-        n = len(positions)
-        indices = list(range(n))
-        stack = []
+    def survivedRobotsHealths(self, positions, healths, directions):
+        idx = sorted(range(len(positions)), key=lambda i: positions[i])
+        stk = []
 
-        indices.sort(key=lambda i: positions[i])
+        for i in idx:
+            if directions[i] == "R":
+                stk.append(i)
+                continue
 
-        for currentIndex in indices:
-            if directions[currentIndex] == "R":
-                stack.append(currentIndex)
-            else:
-                while stack and healths[currentIndex] > 0:
-                    topIndex = stack.pop()
+            while stk and healths[i]:
+                j = stk[-1]
+                if healths[j] > healths[i]:
+                    healths[j] -= 1
+                    healths[i] = 0
+                elif healths[j] < healths[i]:
+                    healths[i] -= 1
+                    healths[j] = 0
+                    stk.pop()
+                else:
+                    healths[i] = healths[j] = 0
+                    stk.pop()
+                    break
 
-                    if healths[topIndex] > healths[currentIndex]:
-                        healths[topIndex] -= 1
-                        healths[currentIndex] = 0
-                        stack.append(topIndex)
-                    elif healths[topIndex] < healths[currentIndex]:
-                        healths[currentIndex] -= 1
-                        healths[topIndex] = 0
-                    else:
-                        healths[currentIndex] = 0
-                        healths[topIndex] = 0
-
-        result = [health for health in healths if health > 0]
-        return result
+        return [h for h in healths if h > 0]

solution/2700-2799/2751.Robot Collisions/Solution.js

@@ -3,36 +3,34 @@ function survivedRobotsHealths(
     healths: number[],
     directions: string,
 ): number[] {
-    const idx = Array.from({ length: positions.length }, (_, i) => i);
-    const stk: number[] = [];
+    const n = positions.length;
+    const idx = Array.from({ length: n }, (_, i) => i).sort((a, b) => positions[a] - positions[b]);
 
-    idx.sort((a, b) => positions[a] - positions[b]);
+    const stk: number[] = [];
 
-    for (let iRight of idx) {
-        while (stk.length) {
-            const iLeft = stk.at(-1)!;
-            const havePair = directions[iLeft] === 'R' && directions[iRight] === 'L';
-            if (!havePair) break;
+    for (const i of idx) {
+        if (directions[i] === 'R') {
+            stk.push(i);
+            continue;
+        }
 
-            if (healths[iLeft] === healths[iRight]) {
-                healths[iLeft] = healths[iRight] = iRight = -1;
-                stk.pop();
-                break;
-            }
+        while (stk.length && healths[i] > 0) {
+            const j = stk[stk.length - 1];
 
-            if (healths[iLeft] < healths[iRight]) {
-                healths[iLeft] = -1;
-                healths[iRight]--;
+            if (healths[j] > healths[i]) {
+                healths[j]--;
+                healths[i] = 0;
+            } else if (healths[j] < healths[i]) {
+                healths[i]--;
+                healths[j] = 0;
                 stk.pop();
             } else {
-                healths[iRight] = iRight = -1;
-                healths[iLeft]--;
+                healths[i] = healths[j] = 0;
+                stk.pop();
                 break;
             }
         }
-
-        if (iRight !== -1) stk.push(iRight);
     }
 
-    return healths.filter(i => ~i);
+    return healths.filter(h => h > 0);
 }