Find and replace in string

/*
 * You are given a 0-indexed string s that you must perform k replacement operations on. The replacement operations are given as three 0-indexed parallel arrays, indices, sources, and targets, all of length k.
 * To complete the ith replacement operation:
 * Check if the substring sources[i] occurs at index indices[i] in the original string s.
 * If it does not occur, do nothing.
 * Otherwise if it does occur, replace that substring with targets[i].
 * For example, if s = "abcd", indices[i] = 0, sources[i] = "ab", and targets[i] = "eee", then the result of this replacement will be "eeecd".
 * All replacement operations must occur simultaneously, meaning the replacement operations should not affect the indexing of each other. The testcases will be generated such that the replacements will not overlap.
 * For example, a testcase with s = "abc", indices = [0, 1], and sources = ["ab","bc"] will not be generated because the "ab" and "bc" replacements overlap.
 * Return the resulting string after performing all replacement operations on s.
 * A substring is a contiguous sequence of characters in a string.
 * Example 1:
 * Input: s = "abcd", indices = [0, 2], sources = ["a", "cd"], targets = ["eee", "ffff"]
 * Output: "eeebffff"
 * Explanation:
 * "a" occurs at index 0 in s, so we replace it with "eee".
 * "cd" occurs at index 2 in s, so we replace it with "ffff".
 * Example 2:
 * Input: s = "abcd", indices = [0, 2], sources = ["ab","ec"], targets = ["eee","ffff"]
 * Output: "eeecd"
 * Explanation:
 * "ab" occurs at index 0 in s, so we replace it with "eee".
 * "ec" does not occur at index 2 in s, so we do nothing.
 * Constraints:
 * 1 <= s.length <= 1000
 * k == indices.length == sources.length == targets.length
 * 1 <= k <= 100
 * 0 <= indexes[i] < s.length
 * 1 <= sources[i].length, targets[i].length <= 50
 * s consists of only lowercase English letters.
 * sources[i] and targets[i] consist of only lowercase English letters.
 */

impl Solution {
  pub fn find_replace_string(s: String, indices: Vec<i32>, sources: Vec<String>, targets: Vec<String>) -> String {
    let s_bytes = s.as_bytes();
    // Pre-check each op against the original string; collect only matching ones
    let mut ops: Vec<(usize, &str, &str)> = indices.iter()
      .zip(sources.iter())
      .zip(targets.iter())
      .filter_map(|((&i, src), tgt)| {
        let idx = i as usize;
        if s_bytes[idx..].starts_with(src.as_bytes()) {
          Some((idx, src.as_str(), tgt.as_str()))
        } else {
          None
        }
      })
      .collect();
    // Sort by index descending so we can replace without shifting
    ops.sort_by(|a, b| b.0.cmp(&a.0));
    let mut result = s;
    for (idx, src, tgt) in ops {
      result = format!("{}{}{}", &result[..idx], tgt, &result[idx+src.len()..]);
    }
    result
  }
}