- 字符串中的查找与替换
你会得到一个字符串 s (索引从 0 开始),你必须对它执行 k 个替换操作。替换操作以三个长度均为 k 的并行数组给出:indices, sources, targets。
要完成第 i 个替换操作:
检查 子字符串 sources[i] 是否出现在 原字符串 s 的索引 indices[i] 处。
如果没有出现, 什么也不做 。
如果出现,则用 targets[i] 替换 该子字符串。
例如,如果 s = “abcd” , indices[i] = 0 , sources[i] = “ab”, targets[i] = “eee” ,那么替换的结果将是 “eeecd” 。
所有替换操作必须 同时 发生,这意味着替换操作不应该影响彼此的索引。测试用例保证元素间不会重叠 。
例如,一个 s = “abc” , indices = [0,1] , sources = [“ab”,“bc”] 的测试用例将不会生成,因为 “ab” 和 “bc” 替换重叠。
在对 s 执行所有替换操作后返回 结果字符串 。
子字符串 是字符串中连续的字符序列。
示例 1:
输入:s = “abcd”, indexes = [0,2], sources = [“a”,“cd”], targets = [“eee”,“ffff”]
输出:“eeebffff”
解释:
“a” 从 s 中的索引 0 开始,所以它被替换为 “eee”。
“cd” 从 s 中的索引 2 开始,所以它被替换为 “ffff”。
示例 2:
输入:s = “abcd”, indexes = [0,2], sources = [“ab”,“ec”], targets = [“eee”,“ffff”]
输出:“eeecd”
解释:
“ab” 从 s 中的索引 0 开始,所以它被替换为 “eee”。
“ec” 没有从原始的 S 中的索引 2 开始,所以它没有被替换。
C代码:
#define MAX_RET_LEN 5001
typedef struct {
int index;
char *source;
char *target;
} Change;
int Cmp(const void *a, const void *b) {
Change *x = (Change *)a;
Change *y = (Change *)b;
return x->index - y->index;
}
char * findReplaceString(char * S, int* indexes, int indexesSize, char ** sources, int sourcesSize, char ** targets, int targetsSize){
char *ret = NULL;
int i, j, k, num, start;
int lenS = strlen(S);
Change *change = NULL;
ret = (char *)malloc(sizeof(char) * MAX_RET_LEN);
memset(ret, 0, sizeof(char) * MAX_RET_LEN);
if (lenS == 0) {
return ret;
}
change = (Change *)malloc(sizeof(Change) * indexesSize);
memset(change, 0, sizeof(Change) * indexesSize);
for (i = 0; i < indexesSize; i++) {
change[i].index = indexes[i];
change[i].source = sources[i];
change[i].target = targets[i];
}
qsort(change, indexesSize, sizeof(Change), Cmp);
for (i = 0, j = 0, k = 0; i < lenS;) {
//printf("i=%d, j=%d, k=%d ", i, j ,k);
if (j == indexesSize || i != change[j].index) {
ret[k] = S[i];
k++;
i++;
continue;
}
//比较source和S对应index处的子串是否相等
num = 0;
start = i;
while (i < lenS && num < strlen(change[j].source) && S[i] == change[j].source[num]) {
num++;
i++;
}
if (num == strlen(change[j].source)) {
memcpy(ret + k, change[j].target, strlen(change[j].target));
k += strlen(change[j].target);
} else {
i = start;
ret[k] = S[i];
k++;
i++;
}
j++;
}
return ret;
}
Java代码:
class Solution {
public String findReplaceString(String S, int[] indexes, String[] sources, String[] targets) {
int[] array = new int[S.length()];
int[] temp = new int[S.length()];
for (int i = 0; i < indexes.length; i++) {
if (S.startsWith(sources[i], indexes[i])) {
array[indexes[i]] = sources[i].length();
temp[indexes[i]] = i;
}
}
StringBuilder sb = new StringBuilder();
for (int i = 0, j = 0; j <= array.length; j++) {
if (j == array.length) {
sb.append(S.substring(i));
break;
}
if (array[j] > 0) {
sb.append(S.substring(i, j)).append(targets[temp[j]]);
i = j + array[j];
}
}
return sb.toString();
}
}