## 1678. Goal Parser Interpretation

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.

## Rust Solution

``````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);
}
``````

Having problems with this solution? Click here to submit an issue on github.