Robot Collisions solution and explanation

def surviving_robots_health(positions, healths, directions):
    robots = sorted(zip(positions, healths, directions, range(len(positions))), key=lambda x: x[0])
    survivors = [True] * len(robots)
    stack = []  # this will store indices of robots moving 'R'

    for _, health, direction, index in robots:
        if direction == 'R':
            stack.append((health, index))
        else:
            while stack and stack[-1][0] < health:
                health -= 1
                prev_health, prev_index = stack.pop()
                survivors[prev_index] = False
            if stack:
                if stack[-1][0] == health:
                    survivors[stack.pop()[1]] = False
                    survivors[index] = False
                else:
                    stack[-1] = (stack[-1][0] - 1, stack[-1][1])
                    survivors[index] = False

    return [h for (_, h, _, i), s in zip(robots, survivors) if s]

import java.util.*;

class RobotCollision {
    public List<Integer> survivingRobotsHealth(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;
        Arrays.sort(indices, Comparator.comparingInt(i -> positions[i]));

        List<Integer> result = new ArrayList<>();
        Deque<Integer> stack = new ArrayDeque<>();

        boolean[] survivor = new boolean[n];
        Arrays.fill(survivor, true);

        for (int idx : indices) {
            if (directions.charAt(idx) == 'R') {
                stack.push(idx);
            } else {
                while (!stack.isEmpty() && healths[stack.peek()] < healths[idx]) {
                    int rIdx = stack.pop();
                    healths[idx]--;
                    survivor[rIdx] = false;
                }
                if (!stack.isEmpty() && healths[stack.peek()] == healths[idx]) {
                    survivor[stack.pop()] = false;
                    survivor[idx] = false;
                } else if (!stack.isEmpty()) {
                    healths[stack.peek()]--;
                    survivor[idx] = false;
                }
            }
        }

        for (int i = 0; i < n; i++) {
            if (survivor[i]) {
                result.add(healths[i]);
            }
        }

        return result;
    }
}

function survivingRobotsHealth(positions, healths, directions) {
  let n = positions.length;
  let robots = directions.split('').map((d, i) => ({ pos: positions[i], health: healths[i], dir: d, idx: i }));

  robots.sort((a, b) => a.pos - b.pos);
  let survivors = Array(n).fill(true);
  let stack = [];

  robots.forEach(({ dir, health, idx }, i) => {
    if (dir === 'R') {
      stack.push({ health, idx });
    } else {
      while (stack.length > 0 && stack[stack.length - 1].health < health) {
        health -= 1;
        let top = stack.pop();
        survivors[top.idx] = false;
      }
      if (stack.length > 0 && stack[stack.length - 1].health === health) {
        survivors[stack.pop().idx] = false;
        survivors[idx] = false;
      } else if (stack.length > 0) {
        stack[stack.length - 1].health -= 1;
        survivors[idx] = false;
      }
    }
  });

  return robots.filter(({ idx }) => survivors[idx]).map(({ health }) => health);
}

#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>

typedef struct { int pos, health, idx; char dir; } Robot;

int compare(const void* a, const void* b) {
    return ((Robot*)a)->pos - ((Robot*)b)->pos;
}

int* survivingRobotsHealth(int* positions, int positionsSize, int* healths, char* directions, int* returnSize) {
    Robot* robots = malloc(positionsSize * sizeof(Robot));
    bool* survivors = malloc(positionsSize * sizeof(bool));
    for (int i = 0; i < positionsSize; i++) {
        robots[i] = (Robot){positions[i], healths[i], i, directions[i] };
        survivors[i] = true;
    }
    qsort(robots, positionsSize, sizeof(Robot), compare);

    int* stack = malloc(positionsSize * sizeof(int));
    int top = -1;

    for (int i = 0; i < positionsSize; i++) {
        if (robots[i].dir == 'R') {
            stack[++top] = i;
        }
        else {
            while (top >= 0 && robots[stack[top]].health < robots[i].health) {
                robots[i].health -= 1;
                survivors[robots[stack[top]--].idx] = false;
            }
            if (top >= 0 && robots[stack[top]].health == robots[i].health) {
                survivors[robots[stack[top--]].idx] = false;
                survivors[robots[i].idx] = false;
            } else if (top >= 0) {
                robots[stack[top]].health -= 1;
                survivors[robots[i].idx] = false;
            }
        }
    }

    int* result = malloc(positionsSize * sizeof(int));
    int count = 0;
    for (int i = 0; i < positionsSize; i++) {
        if (survivors[robots[i].idx]) {
            result[count++] = robots[i].health;
        }
    }

    *returnSize = count;
    free(robots);
    free(survivors);
    free(stack);
    return result;
}

class Solution {
public:
    vector<int> survivedRobotsHealths(vector<int>& positions, vector<int>& healths, string directions) {
        int n = positions.size();
        vector<int> idx(n);
        iota(idx.begin(), idx.end(), 0);

        sort(idx.begin(), idx.end(), [&](int a, int b) {
            return positions[a] < positions[b];
        });

        vector<int> stk;

        for (int i : idx) {
            if (directions[i] == 'R') {
                stk.push_back(i);
                continue;
            }

            while (!stk.empty() && healths[i] > 0) {
                int j = stk.back();

                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;
                }
            }
        }

        vector<int> ans;
        for (int h : healths) {
            if (h > 0) {
                ans.push_back(h);
            }
        }
        return ans;
    }
};

function survivedRobotsHealths(
    positions: number[],
    healths: number[],
    directions: string,
): number[] {
    const n = positions.length;
    const idx = Array.from({ length: n }, (_, i) => i).sort((a, b) => positions[a] - positions[b]);

    const stk: number[] = [];

    for (const i of idx) {
        if (directions[i] === 'R') {
            stk.push(i);
            continue;
        }

        while (stk.length && healths[i] > 0) {
            const j = stk[stk.length - 1];

            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;
            }
        }
    }

    return healths.filter(h => h > 0);
}

func survivedRobotsHealths(positions []int, healths []int, directions string) []int {
	n := len(positions)
	idx := make([]int, n)
	for i := range idx {
		idx[i] = i
	}

	sort.Slice(idx, func(i, j int) bool {
		return positions[idx[i]] < positions[idx[j]]
	})

	stk := []int{}

	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[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
			}
		}
	}

	ans := []int{}
	for _, h := range healths {
		if h > 0 {
			ans = append(ans, h)
		}
	}
	return ans
}

impl Solution {
    pub fn survived_robots_healths(
        positions: Vec<i32>,
        mut healths: Vec<i32>,
        directions: String
    ) -> Vec<i32> {
        let n = positions.len();
        let mut idx: Vec<usize> = (0..n).collect();

        idx.sort_by_key(|&i| positions[i]);

        let dirs = directions.as_bytes();
        let mut stk: Vec<usize> = Vec::new();

        for &i in &idx {
            if dirs[i] == b'R' {
                stk.push(i);
                continue;
            }

            while let Some(&j) = stk.last() {
                if healths[i] == 0 {
                    break;
                }

                if healths[j] > healths[i] {
                    healths[j] -= 1;
                    healths[i] = 0;
                    break;
                } else if healths[j] < healths[i] {
                    healths[i] -= 1;
                    healths[j] = 0;
                    stk.pop();
                } else {
                    healths[i] = 0;
                    healths[j] = 0;
                    stk.pop();
                    break;
                }
            }
        }

        healths.into_iter().filter(|&h| h > 0).collect()
    }
}