Find And Replace in String solution and explanation

def findReplaceString(s: str, indices: List[int], sources: List[str], targets: List[str]) -> str:
    replacements = sorted(zip(indices, sources, targets), reverse=True)
    for i, source, target in replacements:
        if s[i:i + len(source)] == source:
            s = s[:i] + target + s[i + len(source):]
    return s

import java.util.*;

class Pair {
    int index, pos;
    Pair(int index, int pos) {
        this.index = index;
        this.pos = pos;
    }
}

public class Solution {
    public String findReplaceString(String s, int[] indices, String[] sources, String[] targets) {
        int n = indices.length;
        List<Pair> sortedIndices = new ArrayList<>();
        for (int i = 0; i < n; ++i) {
            sortedIndices.add(new Pair(indices[i], i));
        }

        sortedIndices.sort((a, b) -> b.index - a.index);
        StringBuilder result = new StringBuilder(s);

        for (Pair pair : sortedIndices) {
            int i = pair.index;
            int iglobal = pair.pos;
            if (s.startsWith(sources[iglobal], i)) {
                result.replace(i, i + sources[iglobal].length(), targets[iglobal]);
            }
        }
        return result.toString();
    }
}

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>

using namespace std;

string findReplaceString(string s, vector<int>& indices, vector<string>& sources, vector<string>& targets) {
    vector<pair<int, int>> sorted_indices;
    int n = indices.size();
    for (int i = 0; i < n; ++i) {
        sorted_indices.push_back({indices[i], i});
    }

    sort(sorted_indices.begin(), sorted_indices.end(), greater<>());
    for (auto& pair : sorted_indices) {
        int i = pair.first;
        int idx = pair.second;
        if (s.substr(i, sources[idx].size()) == sources[idx]) {
            s = s.substr(0, i) + targets[idx] + s.substr(i + sources[idx].size());
        }
    }
    return s;
}

var findReplaceString = function(s, indices, sources, targets) {
    let sortedIndices = [];
    for (let i = 0; i < indices.length; i++) {
        sortedIndices.push([indices[i], i]);
    }
    sortedIndices.sort((a, b) => b[0] - a[0]);

    for (const [index, pos] of sortedIndices) {
        const source = sources[pos];
        const target = targets[pos];
        if (s.substr(index, source.length) === source) {
            s = s.substring(0, index) + target + s.substring(index + source.length);
        }
    }
    return s;
};

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

typedef struct {
    int index;
    char* source;
    char* target;
} ReplacementInfo;

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

char* findReplaceString(char* s, int* indices, int indicesSize, char** sources, char** targets) {
    int s_len = strlen(s);
    char* result = (char*)malloc(sizeof(char) * (s_len + 1));
    strcpy(result, s);

    ReplacementInfo* replacements = (ReplacementInfo*)malloc(sizeof(ReplacementInfo) * indicesSize);
    for (int i = 0; i < indicesSize; ++i) {
        replacements[i].index = indices[i];
        replacements[i].source = sources[i];
        replacements[i].target = targets[i];
    }

    qsort(replacements, indicesSize, sizeof(ReplacementInfo), compare);

    for (int i = 0; i < indicesSize; ++i) {
        int index = replacements[i].index;
        char* source = replacements[i].source;
        char* target = replacements[i].target;
        if (strncmp(&s[index], source, strlen(source)) == 0) {
            // Perform replacement
            char* temp = (char*)malloc(strlen(result) + strlen(target) - strlen(source) + 1);
            strncpy(temp, result, index);
            temp[index] = '\0';
            strcat(temp, target);
            strcat(temp, &result[index + strlen(source)]);
            free(result);
            result = temp;
        }
    }
    free(replacements);
    return result;
}

using System;
using System.Collections.Generic;

public class Solution {
    public string FindReplaceString(string s, int[] indices, string[] sources, string[] targets) {
        List<(int Index, int Pos)> sortedIndices = new List<(int, int)>();
        for (int i = 0; i < indices.Length; ++i) {
            sortedIndices.Add((indices[i], i));
        }
        sortedIndices.Sort((a, b) => b.Index.CompareTo(a.Index));

        foreach (var (i, pos) in sortedIndices) {
            if (s.Substring(i, sources[pos].Length) == sources[pos]) {
                s = s.Substring(0, i) + targets[pos] + s.Substring(i + sources[pos].Length);
            }
        }

        return s;
    }
}

def findReplaceString(s: str, indices: List[int], sources: List[str], targets: List[str]) -> str:
    result = list(s)
    for index, source, target in zip(indices, sources, targets):
        if s.startswith(source, index):
            result[index:index+len(source)] = list(target)
    return ''.join(result)

import java.util.*;

public class Solution {
    public String findReplaceString(String s, int[] indices, String[] sources, String[] targets) {
        char[] result = s.toCharArray();
        for (int i = 0; i < indices.length; i++) {
            int index = indices[i];
            String source = sources[i];
            String target = targets[i];
            if (s.startsWith(source, index)) {
                int len = source.length();
                for (int j = 0; j < len; j++) result[index + j] = ' ';
                System.arraycopy(target.toCharArray(), 0, result, index, target.length());
            }
        }
        return new String(result).replaceAll(" ", "");
    }
}

var findReplaceString = function(s, indices, sources, targets) {
    let result = Array.from(s);
    for (let i = 0; i < indices.length; i++) {
        let index = indices[i];
        let source = sources[i];
        let target = targets[i];
        if (s.startsWith(source, index)) {
            result.splice(index, source.length, ...target);
        }
    }
    return result.join('');
};

function findReplaceString(
    s: string,
    indices: number[],
    sources: string[],
    targets: string[],
): string {
    const n = s.length;
    const d: number[] = Array(n).fill(-1);
    for (let k = 0; k < indices.length; ++k) {
        const [i, src] = [indices[k], sources[k]];
        if (s.startsWith(src, i)) {
            d[i] = k;
        }
    }
    const ans: string[] = [];
    for (let i = 0; i < n; ) {
        if (d[i] >= 0) {
            ans.push(targets[d[i]]);
            i += sources[d[i]].length;
        } else {
            ans.push(s[i++]);
        }
    }
    return ans.join('');
}

func findReplaceString(s string, indices []int, sources []string, targets []string) string {
	n := len(s)
	d := make([]int, n)
	for k, i := range indices {
		if strings.HasPrefix(s[i:], sources[k]) {
			d[i] = k + 1
		}
	}
	ans := &strings.Builder{}
	for i := 0; i < n; {
		if d[i] > 0 {
			ans.WriteString(targets[d[i]-1])
			i += len(sources[d[i]-1])
		} else {
			ans.WriteByte(s[i])
			i++
		}
	}
	return ans.String()
}