You own a Goal Parser that can interpret a string command
. The command
consists of an alphabet of "G"
, "()"
and/or "(al)"
in some order. The Goal Parser will interpret "G"
as the string "G"
, "()"
as the string "o"
, and "(al)"
as the string "al"
. The interpreted strings are then concatenated in the original order.
Given the string command
, return the Goal Parser's interpretation of command
.
Example 1:
Input: command = "G()(al)" Output: "Goal" Explanation: The Goal Parser interprets the command as follows: G -> G () -> o (al) -> al The final concatenated result is "Goal".
Example 2:
Input: command = "G()()()()(al)" Output: "Gooooal"
Example 3:
Input: command = "(al)G(al)()()G" Output: "alGalooG"
Constraints:
1 <= command.length <= 100
command
consists of "G"
, "()"
, and/or "(al)"
in some order.struct Solution;
impl Solution {
fn interpret(command: String) -> String {
let mut it = command.chars().peekable();
let mut res = "".to_string();
while let Some(c) = it.next() {
match c {
'G' => {
res.push('G');
}
_ => {
let next = it.next().unwrap();
if next == ')' {
res.push('o');
} else {
it.next();
it.next();
res.push('a');
res.push('l');
}
}
}
}
res
}
}
#[test]
fn test() {
let command = "G()(al)".to_string();
let res = "Goal".to_string();
assert_eq!(Solution::interpret(command), res);
let command = "G()()()()(al)".to_string();
let res = "Gooooal".to_string();
assert_eq!(Solution::interpret(command), res);
let command = "(al)G(al)()()G".to_string();
let res = "alGalooG".to_string();
assert_eq!(Solution::interpret(command), res);
}