给出由小写字母组成的字符串 S，重复项删除操作会选择两个相邻且相同的字母，并删除它们。

在 S 上反复执行重复项删除操作，直到无法继续删除。

在完成所有重复项删除操作后返回最终的字符串。答案保证唯一。

示例：

输入："abbbaca"

输出："ca"

解释：

例如，在 "abbaca" 中，我们可以删除 "bbb" 由于两字母相邻且相同，这是此时唯一可以执行删除操作的重复项。之后我们得到字符串 "aaca"，其中又只有 "aa" 可以执行重复项删除操作，所以最后的字符串为 "ca"。

有效括号字符串为空 ("")、"(" + A + ")" 或 A + B，其中 A 和 B 都是有效的括号字符串，+ 代表字符串的连接。例如，""，"()"，"(())()" 和 "(()(()))" 都是有效的括号字符串。

如果有效字符串 S 非空，且不存在将其拆分为 S = A+B 的方法，我们称其为原语（primitive），其中 A 和 B 都是非空有效括号字符串。

给出一个非空有效字符串 S，考虑将其进行原语化分解，使得：S = P_1 + P_2 + ... + P_k，其中 P_i 是有效括号字符串原语。

对 S 进行原语化分解，删除分解中每个原语字符串的最外层括号，返回 S 。

示例：

输入："(()())(())"

输出："()()()"

解释：

输入字符串为 "(()())(())"，原语化分解得到 "(()())" + "(())"，

删除每个部分中的最外层括号后得到 "()()" + "()" = "()()()"。

代码：

遍历字符串

* 左括号入栈：若入栈后栈的长度大于1，即该左括号不是原语首个左括号，结果加入'('

* 右括号出栈：若出栈后栈的长度大于0，即该右括号不是原语末个右括号，结果加入')'

def removeOuterParentheses(S):

stack = []

result = ''

for i in S:

if i == '(':

stack.append(i)

if len(stack) > 1:

result += '('

else:

stack.pop()

if len(stack) != 0:

result += ')'

return result

你现在是一场采特殊赛制棒球比赛的记录员。这场比赛由若干回合组成，过去几回合的得分可能会影响以后几回合的得分。

比赛开始时，记录是空白的。你会得到一个记录操作的字符串列表 ops，其中 ops[i] 是你需要记录的第 i 项操作，ops 遵循下述规则：

* 整数 x - 表示本回合新获得分数 x

* \+ 表示本回合新获得的得分是前两次得分的总和。题目数据保证记录此操作时前面总是存在两个有效的分数。

* "D" - 表示本回合新获得的得分是前一次得分的两倍。题目数据保证记录此操作时前面总是存在一个有效的分数。

* "C" - 表示前一次得分无效，将其从记录中移除。题目数据保证记录此操作时前面总是存在一个有效的分数。

* 请你返回记录中所有得分的总和。

示例：

输入：ops = ["5","2","C","D","+"]

输出：30

解释：

"5" - 记录加 5 ，记录现在是 [5]

"2" - 记录加 2 ，记录现在是 [5, 2]

"C" - 使前一次得分的记录无效并将其移除，记录现在是 [5].

"D" - 记录加 2 * 5 = 10 ，记录现在是 [5, 10].

"+" - 记录加 5 + 10 = 15 ，记录现在是 [5, 10, 15].

所有得分的总和 5 + 10 + 15 = 30

代码：

* 碰到数字字符串就入栈

* 碰到 "+" "C" "D"就弹栈，计算之后，再把数据入栈

def calPoints(ops):

res = []

for item in ops:

if item not in ['+', 'D', 'C']:

res.append(int(item))

if item == '+':

tmp1 = res.pop()

tmp2 = res.pop()

res.append(tmp2)

res.append(tmp1)

res.append(tmp2 + tmp1)

if item == 'D':

tmp1 = res.pop()

res.append(tmp1)

res.append(tmp1 * 2)

if item == 'C':

res.pop()

return sum(res)

给定 S 和 T 两个字符串，当它们分别被输入到空白的文本编辑器后，判断二者是否相等，并返回结果。 # 代表退格字符。

注意：如果对空文本输入退格字符，文本继续为空。

示例：

输入：S = "ab#c", T = "ad#c"

输出：true

解释：S 和 T 都会变成 “ac”。

代码：

* 碰到“#”就弹栈

* 碰到其他字符就入栈

def backspaceCompare(S, T):

s_stack = []

t_stack = []

for item in S:

if item == '#' and s_stack:

s_stack.pop()

if item != '#':

s_stack.append(item)

for item in T:

if item == '#' and t_stack:

t_stack.pop()

if item != '#':

t_stack.append(item)

return s_stack == t_stack