Question

1678. 设计 Goal 解析器

English Version

题目描述

请你设计一个可以解释字符串 command 的 Goal 解析器 。command 由 "G"、"()" 和/或 "(al)" 按某种顺序组成。Goal 解析器会将 "G" 解释为字符串 "G"、"()" 解释为字符串 "o" ，"(al)" 解释为字符串 "al" 。然后，按原顺序将经解释得到的字符串连接成一个字符串。

给你字符串 command ，返回_ _Goal_ _解析器 对_ _command 的解释结果。

 

示例 1：

输入：command = "G()(al)"
输出："Goal"
解释：Goal 解析器解释命令的步骤如下所示：
G -> G
() -> o
(al) -> al
最后连接得到的结果是 "Goal"

示例 2：

输入：command = "G()()()()(al)"
输出："Gooooal"

示例 3：

输入：command = "(al)G(al)()()G"
输出："alGalooG"

 

提示：

• 1 <= command.length <= 100
• command 由 "G"、"()" 和/或 "(al)" 按某种顺序组成

解法

方法一：字符串替换

根据题意，只需要将字符串 command 中的 "()" 替换为 'o'，"(al)" 替换为 "al" 即可。

时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 是字符串 $command$ 的长度。

class Solution:
  def interpret(self, command: str) -> str:
    return command.replace('()', 'o').replace('(al)', 'al')

class Solution {
  public String interpret(String command) {
    return command.replace("()", "o").replace("(al)", "al");
  }
}

class Solution {
public:
  string interpret(string command) {
    while (command.find("()") != -1) command.replace(command.find("()"), 2, "o");
    while (command.find("(al)") != -1) command.replace(command.find("(al)"), 4, "al");
    return command;
  }
};

func interpret(command string) string {
  command = strings.ReplaceAll(command, "()", "o")
  command = strings.ReplaceAll(command, "(al)", "al")
  return command
}

function interpret(command: string): string {
  return command.replace(/\(\)/g, 'o').replace(/\(al\)/g, 'al');
}

impl Solution {
  pub fn interpret(command: String) -> String {
    command.replace("()", "o").replace("(al)", "al")
  }
}

char* interpret(char* command) {
  int n = strlen(command);
  char* ans = malloc(sizeof(char) * n + 1);
  int i = 0;
  for (int j = 0; j < n; j++) {
    char c = command[j];
    if (c == 'G') {
      ans[i++] = 'G';
    } else if (c == '(') {
      if (command[j + 1] == ')') {
        ans[i++] = 'o';
      } else {
        ans[i++] = 'a';
        ans[i++] = 'l';
      }
    }
  }
  ans[i] = '\0';
  return ans;
}

方法二：字符串遍历

我们也可以遍历字符串 command，对于每个字符 $c$：

• 如果是 'G'，直接将 $c$ 添加到结果串中；
• 如果是 '('，判断下一个字符是否是 ')'，若是，将 'o' 添加到结果串中，否则，将 "al" 添加到结果串中。

遍历结束，返回结果串即可。

时间复杂度 $O(n)$，其中 $n$ 是字符串 $command$ 的长度。空间复杂度 $O(1)$。

class Solution:
  def interpret(self, command: str) -> str:
    ans = []
    for i, c in enumerate(command):
      if c == 'G':
        ans.append(c)
      elif c == '(':
        ans.append('o' if command[i + 1] == ')' else 'al')
    return ''.join(ans)

class Solution {
  public String interpret(String command) {
    StringBuilder ans = new StringBuilder();
    for (int i = 0; i < command.length(); ++i) {
      char c = command.charAt(i);
      if (c == 'G') {
        ans.append(c);
      } else if (c == '(') {
        ans.append(command.charAt(i + 1) == ')' ? "o" : "al");
      }
    }
    return ans.toString();
  }
}

class Solution {
public:
  string interpret(string command) {
    string ans;
    for (int i = 0; i < command.size(); ++i) {
      char c = command[i];
      if (c == 'G')
        ans += c;
      else if (c == '(')
        ans += command[i + 1] == ')' ? "o" : "al";
    }
    return ans;
  }
};

func interpret(command string) string {
  ans := &strings.Builder{}
  for i, c := range command {
    if c == 'G' {
      ans.WriteRune(c)
    } else if c == '(' {
      if command[i+1] == ')' {
        ans.WriteByte('o')
      } else {
        ans.WriteString("al")
      }
    }
  }
  return ans.String()
}

function interpret(command: string): string {
  const n = command.length;
  const ans: string[] = [];
  for (let i = 0; i < n; i++) {
    const c = command[i];
    if (c === 'G') {
      ans.push(c);
    } else if (c === '(') {
      ans.push(command[i + 1] === ')' ? 'o' : 'al');
    }
  }
  return ans.join('');
}

impl Solution {
  pub fn interpret(command: String) -> String {
    let mut ans = String::new();
    let bs = command.as_bytes();
    for i in 0..bs.len() {
      if bs[i] == b'G' {
        ans.push_str("G");
      }
      if bs[i] == b'(' {
        ans.push_str({
          if bs[i + 1] == b')' { "o" } else { "al" }
        });
      }
    }
    ans
  }
}