替换字符串中的括号内容

1807. 替换字符串中的括号内容

给你一个字符串 s ，它包含一些括号对，每个括号中包含一个非空的键。

比方说，字符串 "(name)is(age)yearsold" 中，有两个括号对，分别包含键 "name" 和 "age" 。

你知道许多键对应的值，这些关系由二维字符串数组 knowledge 表示，其中 knowledge[i] = [key_i, value_i] ，表示键 key_i 对应的值为 value_i。

你需要替换所有的括号对。当你替换一个括号对，且它包含的键为 key_i 时，你需要：

将 key_i 和括号用对应的值 value_i 替换。
如果从 knowledge 中无法得知某个键对应的值，你需要将 key_i 和括号用问号 "?" 替换（不需要引号）。

knowledge 中每个键最多只会出现一次。s 中不会有嵌套的括号。

请你返回替换所有括号对后的结果字符串。

示例 1：

输入：s = "(name)is(age)yearsold", knowledge = [["name","bob"],["age","two"]]
输出："bobistwoyearsold"
解释：
键 "name" 对应的值为 "bob" ，所以将 "(name)" 替换为 "bob" 。
键 "age" 对应的值为 "two" ，所以将 "(age)" 替换为 "two" 。

示例 2：

输入：s = "hi(name)", knowledge = [["a","b"]]
输出："hi?"
解释：由于不知道键 "name" 对应的值，所以用 "?" 替换 "(name)" 。

示例 3：

输入：s = "(a)(a)(a)aaa", knowledge = [["a","yes"]]
输出："yesyesyesaaa"
解释：相同的键在 s 中可能会出现多次。
键 "a" 对应的值为 "yes" ，所以将所有的 "(a)" 替换为 "yes" 。
注意，不在括号里的 "a" 不需要被替换。

提示：

1 <= s.length <= 10⁵
0 <= knowledge.length <= 10⁵
knowledge[i].length == 2
1 <= key_i.length, value_i.length <= 10
s 只包含小写英文字母和圆括号 '(' 和 ')' 。
s 中每一个左圆括号 '(' 都有对应的右圆括号 ')' 。
s 中每对括号内的键都不会为空。
s 中不会有嵌套括号对。
key_i 和 value_i 只包含小写英文字母。
knowledge 中的 key_i 不会重复。

原站题解

去查看

上次编辑到这里，代码来自缓存点击恢复默认模板

class Solution { public: string evaluate(string s, vector<vector<string>>& knowledge) { } };

golang 解法, 执行用时: 672 ms, 内存消耗: 60.9 MB, 提交时间: 2022-12-04 12:43:48

func evaluate(s string, knowledge [][]string) string {
    i :=0
    res := ""
    dict := make(map[string]string)
    for _,v := range knowledge{
        dict[v[0]] = v[1]
    }
    for i<len(s){
        if s[i]=='('{
            j := i+1
            for j<len(s) && s[j]!=')'{
                j++
            }
            temp := s[i+1:j]
            if dict[temp]==""{
                res = res +"?"
            }else{
                res = res + dict[temp]
            }
            i = j+1
        }else{
            res = res + string(s[i])
            i++
        }
    }
    return res
}

golang 解法, 执行用时: 200 ms, 内存消耗: 30.7 MB, 提交时间: 2022-12-04 12:42:56

func evaluate(s string, knowledge [][]string) string {
    m := make(map[string]string)
    for _, kv := range knowledge {
        m["("+kv[0]+")"] = kv[1]
    }

    rep := func (k string) string {
        v, ok := m[k]
        if !ok {
            return "?"
        }
        return v
    }
    
    return regexp.MustCompile(`\([a-z]+\)`).ReplaceAllStringFunc(s, rep)
}

python3 解法, 执行用时: 128 ms, 内存消耗: 50.7 MB, 提交时间: 2022-12-04 12:42:04

class Solution(object):
    def evaluate(self, s: str, knowledge: List[List[str]]) -> str:
        d = {k: v for k,v in knowledge}
        ans = ""
        isKey = False
        key = ""
        for c in s:
            if c == '(':
                isKey = True
            elif c == ')':
                isKey = False
                if key in d:
                    ans += d[key]
                else:
                    ans += '?'
                key = ""
            elif not isKey:
                ans += c
            else:
                key += c
        return ans

python3 解法, 执行用时: 108 ms, 内存消耗: 50.4 MB, 提交时间: 2022-12-04 12:38:32

class Solution(object):
    def evaluate(self, s: str, knowledge: List[List[str]]) -> str:
        d = {k:v for k, v in knowledge}
        return "".join(list(map(lambda x: x if x[0] != "(" else d[x[1:-1]] if x[1:-1] in d else "?", s.replace("(", " (").replace(")", ") ").split())))

javascript 解法, 执行用时: 244 ms, 内存消耗: 89.9 MB, 提交时间: 2022-12-04 12:37:10

/**
 * @param {string} s
 * @param {string[][]} knowledge
 * @return {string}
 */
var evaluate = function (s, knowledge) {
    let arr1 = [];    // 存储用于最终返回的字符串
    let arr2 = [];    // 用于存储（）中的内容
    let flag = false; // 用于标记当前遍历的字符是否处于()中
    // 将数组转换成map字典
    const map = {};
    knowledge.forEach(item => {
        map[item[0]] = item[1]
    });
    for (let char of s) {
        if (char === '(') {
            // 清空数组arr2，开始准备存储新的内容，同时设置标记为true,表示正在处于（）中
            arr2 = [];
            flag = true;
        } else if (char === ')') {
            // 括号中的内容遍历结束，判断字典中是否有值，将对应的值添加到arr1中，同时标记已经不处于（）中
            arr1.push(map[arr2.join('')] || '?')
            flag = false;
        } else {
            // 如果当前不处于（）中，将内容推送到arr1,否则推送到arr2
            flag ? arr2.push(char) : arr1.push(char);
        }
    }
    return arr1.join('');
};

javascript 解法, 执行用时: 252 ms, 内存消耗: 87 MB, 提交时间: 2022-12-04 12:36:48

/**
 * @param {string} s
 * @param {string[][]} knowledge
 * @return {string}
 */
var evaluate = function (s, knowledge) {
    // 将数组转换成map字典,否则后面每次都要去数组中查找数据，数组很大时会导致超时。
    const map = {};
    knowledge.forEach(item => {
        map[item[0]] = item[1]
    });
    // const map = Object.fromEntries(knowledge); // 也可以这么写，看别人的题解学到的,api学的不扎实呀，我要去学习了~
    s = s.replace(/\(([a-z]+)\)/g, function (p1, p2) {
        return map[p2] || '?';
    })
    return s;
};

python3 解法, 执行用时: 160 ms, 内存消耗: 50.5 MB, 提交时间: 2022-12-04 12:36:23

class Solution:
    def evaluate(self, s, knowledge):
        # 转换knowl为字典
        paras = {i[0]: i[1] for i in knowledge}
        stack = []
        ret = ''
        # 创建转换标识符
        change = False
        for i in s:
            # 当左括号将标识符设置为True
            if i == '(':
                change = True
            elif i == ')':
                # 当遇到右括号，重置标识符与stack并开始判断knowledge
                change = False
                ret += paras.get(''.join(stack), '?')
                stack = []
            else:
                # change为False追加字符串，为True时append栈等待获取key
                if change:
                    stack.append(i)
                else:
                    ret += i
        return ret

上一题

下一题

详情