Update parser and unionfindset
mbinary
parent
795a941adc
commit
b725e58ef8
|
|
@ -197,4 +197,4 @@ def menu():
|
|||
|
||||
|
||||
if __name__ == '__main__':
|
||||
pass
|
||||
menu()
|
||||
|
|
|
|||
|
|
@ -1,6 +1,7 @@
|
|||
class unionFindSet:
|
||||
def __init__(self, S):
|
||||
self.S = {i: i for i in S}
|
||||
self.size = {i: 1 for i in S}
|
||||
|
||||
def find(self, x):
|
||||
if x != self.S[x]:
|
||||
|
|
@ -9,4 +10,9 @@ class unionFindSet:
|
|||
|
||||
def union(self, a, b, key=lambda x: x):
|
||||
x, y = sorted((self.find(a), self.find(b)), key=key)
|
||||
self.S[a] = self.S[b] = self.S[y] = x
|
||||
self.S[y] = x
|
||||
if x != y:
|
||||
self.size[x] += self.size[y]
|
||||
|
||||
def getSize(self, x):
|
||||
return self.size[self.find(x)]
|
||||
|
|
|
|||
|
|
@ -0,0 +1,28 @@
|
|||
#coding: utf-8
|
||||
''' mbinary
|
||||
#######################################################################
|
||||
# File : subarraySum.py
|
||||
# Author: mbinary
|
||||
# Mail: zhuheqin1@gmail.com
|
||||
# Blog: https://mbinary.xyz
|
||||
# Github: https://github.com/mbinary
|
||||
# Created Time: 2020-04-20 16:49
|
||||
# Description: 子数组累加和
|
||||
#######################################################################
|
||||
'''
|
||||
from typing import List
|
||||
|
||||
|
||||
def subarraySum(nums: List[int], k: int) -> int:
|
||||
dic = {0: 1}
|
||||
sm = 0
|
||||
count = 0
|
||||
for i in range(len(nums)):
|
||||
sm += nums[i]
|
||||
if((sm-k) in dic):
|
||||
count += dic[sm-k]
|
||||
if(sm in dic):
|
||||
dic[sm] += 1
|
||||
else:
|
||||
dic[sm] = 1
|
||||
return count
|
||||
|
|
@ -0,0 +1,603 @@
|
|||
# parser
|
||||
先进行词法分析，然后进行语法分析，然后编写递归下降程序。可以将代码形成框架，词法分析每次只需要改变正则表达式部分即可，语法分析代码只需要实现语法对应的函数.
|
||||
我这里列举了4个题目，都可以这样解答。
|
||||
|
||||
|
||||
* [Lisp 语法解析](#lisp-语法解析)
|
||||
* [题目](#题目)
|
||||
* [语法](#语法)
|
||||
* [代码](#代码)
|
||||
* [原子的数量](#原子的数量)
|
||||
* [题目](#题目-1)
|
||||
* [语法](#语法-1)
|
||||
* [代码](#代码-1)
|
||||
* [花括号展开2](#花括号展开2)
|
||||
* [题目](#题目-2)
|
||||
* [语法](#语法-2)
|
||||
* [代码](#代码-2)
|
||||
* [基本计算器4](#基本计算器4)
|
||||
* [题目](#题目-3)
|
||||
* [语法](#语法-3)
|
||||
* [代码](#代码-3)
|
||||
* [更多](#更多)
|
||||
|
||||
## [Lisp 语法解析](https://leetcode-cn.com/problems/parse-lisp-expression/)
|
||||
### 题目
|
||||
|
||||
给定一个类似 Lisp 语句的表达式 expression，求出其计算结果。
|
||||
|
||||
表达式语法如下所示:
|
||||
|
||||
- 表达式可以为整数，let 语法，add 语法，mult 语法，或赋值的变量。表达式的结果总是一个整数。
|
||||
- (整数可以是正整数、负整数、0)
|
||||
- let 语法表示为 (let v1 e1 v2 e2 ... vn en expr), 其中 let 语法总是以字符串 "let" 来表示，接下来会跟随一个或多个交替变量或表达式，也就是说，第一个变量 v1 被分配为表达式 e1 的值，第二个变量 v2 被分配为表达式 e2 的值，以此类推；最终 let 语法的值为 expr 表达式的值。
|
||||
- add 语法表示为 (add e1 e2)，其中 add 语法总是以字符串 "add" 来表示，该语法总是有两个表达式 e1、e2, 该语法的最终结果是 e1 表达式的值与 e2 表达式的值之和。
|
||||
- mult 语法表示为 (mult e1 e2) ，其中 mult 语法总是以字符串 "mult" 表示， 该语法总是有两个表达式 e1、e2，该语法的最终结果是 e1 表达式的值与 e2 表达式的值之积。
|
||||
- 在该题目中，变量的命名以小写字符开始，之后跟随 0 个或多个小写字符或数字。为了方便，"add"，"let"，"mult" 会被定义为 "关键字"，不会在表达式的变量命名中出现。
|
||||
- 最后，要说一下作用域的概念。计算变量名所对应的表达式时，在计算上下文中，首先检查最内层作用域（按括号计），然后按顺序依次检查外部作用域。我们将保证每一个测试的表达式都是合法的。有关作用域的更多详细信息，请参阅示例。
|
||||
|
||||
```
|
||||
>>> (let x -2 y x y)
|
||||
-2
|
||||
>>> (mult 3 (add 2 3))
|
||||
15
|
||||
>>> (let x 2 (mult x 5))
|
||||
10
|
||||
>>> (let x 2 (mult x (let x 3 y 4 (add x y))))
|
||||
14
|
||||
>>> (let x 2 x 3 x)
|
||||
3
|
||||
>>> (let x 2 (add (let x 3 (let x 4 x)) x))
|
||||
6
|
||||
>>> (let a1 3 b2 (add a1 1) b2)
|
||||
4
|
||||
```
|
||||
### 语法
|
||||
```
|
||||
S-> '(' expr ')'
|
||||
expr -> [mult|add] item item | let {word item } item
|
||||
item -> num | word| S
|
||||
```
|
||||
|
||||
### 代码
|
||||
```python [lisp-收起]
|
||||
```
|
||||
```python [lisp-展开]
|
||||
import re
|
||||
from collections import namedtuple
|
||||
left = r'(?P<LEFT>\()'
|
||||
right = r'(?P<RIGHT>\))'
|
||||
word = r'(?P<WORD>[a-z][a-z0-9]*)'
|
||||
num = r'(?P<NUM>(\-)?\d+)'
|
||||
blank = r'(?P<BLANK>\s+)'
|
||||
pt = re.compile('|'.join([left, right, word, num, blank]))
|
||||
|
||||
token = namedtuple('token', ['type', 'value'])
|
||||
|
||||
|
||||
def genToken(s):
|
||||
scanner = pt.scanner(s)
|
||||
for i in iter(scanner.match, None):
|
||||
if i.lastgroup != 'BLANK':
|
||||
yield token(i.lastgroup, i.group(0))
|
||||
|
||||
|
||||
class parser(object):
|
||||
'''grammar:
|
||||
S-> '(' expr ')'
|
||||
expr -> [mult|add] item item | let {word item } item
|
||||
item -> num | word| S
|
||||
'''
|
||||
|
||||
def config(self,s):
|
||||
if s:
|
||||
self.token = [i for i in genToken(s)]
|
||||
self.lookahead = 0
|
||||
self.vars = []
|
||||
|
||||
def parse(self, s):
|
||||
self.config(s)
|
||||
try:
|
||||
return self.S()
|
||||
except Exception as e:
|
||||
return e
|
||||
|
||||
def match(self, curType):
|
||||
sym = self.token[self.lookahead]
|
||||
if sym.type == curType:
|
||||
self.lookahead += 1
|
||||
return sym.value
|
||||
self.errorinfo(f'Expected {curType}, got {sym.value}')
|
||||
|
||||
def errorinfo(self, s, k=None):
|
||||
if k is None:
|
||||
k = self.lookahead
|
||||
pre = ' '.join([t.value for t in self.token[:k]])
|
||||
suf = ' '.join([t.value for t in self.token[k:]])
|
||||
print(pre+' '+suf)
|
||||
print(' '*(len(pre)+1)+'^'*len(self.token[k].value))
|
||||
raise Exception(s)
|
||||
|
||||
def readVar(self, var):
|
||||
for dic in self.vars[::-1]:
|
||||
if var in dic:
|
||||
return dic[var]
|
||||
self.errorinfo(f"Undefined varible '{var}'", self.lookahead-1)
|
||||
|
||||
def S(self):
|
||||
self.vars.append({})
|
||||
self.match('LEFT')
|
||||
ret = self.expr()
|
||||
self.match('RIGHT')
|
||||
self.vars.pop()
|
||||
return ret
|
||||
|
||||
def expr(self):
|
||||
op = self.match('WORD')
|
||||
if op == 'let':
|
||||
while self.token[self.lookahead].type != 'RIGHT':
|
||||
if self.token[self.lookahead].type == 'WORD':
|
||||
var = self.match('WORD')
|
||||
if self.token[self.lookahead].type == 'RIGHT':
|
||||
return self.readVar(var)
|
||||
else:
|
||||
self.vars[-1][var] = self.item()
|
||||
else:
|
||||
return self.item()
|
||||
elif op in {'mult', 'add'}:
|
||||
a = self.item()
|
||||
b = self.item()
|
||||
if op == 'mult':
|
||||
return a*b
|
||||
elif op == 'add':
|
||||
return a+b
|
||||
else:
|
||||
self.errorinfo('Unknown keyword', self.lookahead-1)
|
||||
|
||||
def item(self):
|
||||
if self.token[self.lookahead].type == 'WORD':
|
||||
return self.readVar(self.match('WORD'))
|
||||
elif self.token[self.lookahead].type == 'NUM':
|
||||
return int(self.match('NUM'))
|
||||
else:
|
||||
return self.S()
|
||||
|
||||
|
||||
class Solution(object):
|
||||
def evaluate(self, expression: str) -> int:
|
||||
return parser().parse(expression)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sol = Solution()
|
||||
|
||||
exprs = ['(add -1 2)',
|
||||
'(let x -2 y x y)',
|
||||
'(mult 3 (add 2 3))',
|
||||
'(let x 2 (mult x 5))',
|
||||
'(let x 2 (mult x (let x 3 y 4 (add x y))))',
|
||||
'(let x 2 x 3 x)',
|
||||
'(let x 2 (add (let x 3 (let x 4 x)) x))',
|
||||
'(let a1 3 b2 (add a1 1) b2)',
|
||||
'add 1 2)', # wrongs
|
||||
'(asd 1 2)',
|
||||
'(let a 1 b)',
|
||||
'(let a 1 b 2)'
|
||||
]
|
||||
for e in exprs:
|
||||
print('>>>', e)
|
||||
print(sol.evaluate(e))
|
||||
```
|
||||
|
||||
|
||||
## [原子的数量](https://leetcode-cn.com/problems/number-of-atoms)
|
||||
### 题目
|
||||
|
||||
给定一个化学式 formula（作为字符串），返回每种原子的数量。
|
||||
|
||||
原子总是以一个大写字母开始，接着跟随 0 个或任意个小写字母，表示原子的名字。
|
||||
|
||||
如果数量大于 1，原子后会跟着数字表示原子的数量。如果数量等于 1 则不会跟数字。例如，H2O 和 H2O2 是可行的，但 H1O2 这个表达是不可行的。
|
||||
|
||||
两个化学式连在一起是新的化学式。例如 H2O2He3Mg4 也是化学式。
|
||||
|
||||
一个括号中的化学式和数字（可选择性添加）也是化学式。例如 (H2O2) 和 (H2O2) 3 是化学式。
|
||||
|
||||
给定一个化学式，输出所有原子的数量。格式为：第一个（按字典序）原子的名子，跟着它的数量（如果数量大于 1），然后是第二个原子的名字（按字典序），跟着它的数量（如果数量大于 1），以此类推。
|
||||
```
|
||||
>>> K4(ON(SO3)2)2
|
||||
K4N2O14S4
|
||||
>>> Mg(OH)2
|
||||
H2MgO2
|
||||
```
|
||||
|
||||
### 语法
|
||||
```
|
||||
S-> item | S item
|
||||
item -> word | word num | '(' S ')' num
|
||||
```
|
||||
|
||||
### 代码
|
||||
```python [atom-收起]
|
||||
```
|
||||
```python3 [atom-展开]
|
||||
import re
|
||||
from collections import namedtuple
|
||||
left = r'(?P<LEFT>\()'
|
||||
right = r'(?P<RIGHT>\))'
|
||||
word = r'(?P<WORD>[A-Z][a-z]*)'
|
||||
num = r'(?P<NUM>\d+)'
|
||||
pt = re.compile('|'.join([left, right, word, num]))
|
||||
|
||||
token = namedtuple('token', ['type', 'value'])
|
||||
|
||||
|
||||
def genToken(s):
|
||||
scanner = pt.scanner(s)
|
||||
for i in iter(scanner.match, None):
|
||||
yield token(i.lastgroup, i.group(0))
|
||||
|
||||
|
||||
class parser:
|
||||
'''grammar:
|
||||
S-> item | S item
|
||||
item -> word | word num | '(' S ')' num
|
||||
'''
|
||||
|
||||
def match(self, curType):
|
||||
sym = self.token[self.lookahead]
|
||||
if sym.type == curType:
|
||||
self.lookahead += 1
|
||||
return sym.value
|
||||
raise Exception('Invalid input string')
|
||||
|
||||
def parse(self, s):
|
||||
self.token = [i for i in genToken(s)]
|
||||
self.lookahead = 0
|
||||
return self.S()
|
||||
def S(self):
|
||||
dic = {}
|
||||
while self.lookahead < len(self.token) and self.token[self.lookahead].type != 'RIGHT':
|
||||
cur = self.item()
|
||||
for i in cur:
|
||||
if i in dic:
|
||||
dic[i] += cur[i]
|
||||
else:
|
||||
dic[i] = cur[i]
|
||||
return dic
|
||||
|
||||
def item(self):
|
||||
if self.token[self.lookahead].type == 'WORD':
|
||||
ele = self.match('WORD')
|
||||
n = 1
|
||||
if self.lookahead < len(self.token) and self.token[self.lookahead].type == 'NUM':
|
||||
n = int(self.match('NUM'))
|
||||
return {ele: n}
|
||||
elif self.token[self.lookahead].type == 'LEFT':
|
||||
self.match('LEFT')
|
||||
dic = self.S()
|
||||
self.match('RIGHT')
|
||||
n = int(self.match("NUM"))
|
||||
for i in dic:
|
||||
dic[i] *= n
|
||||
return dic
|
||||
else:
|
||||
print(self.token[self.lookahead])
|
||||
raise Exception('invalid string')
|
||||
|
||||
|
||||
class Solution(object):
|
||||
def countOfAtoms(self, formula):
|
||||
"""
|
||||
:type formula: str
|
||||
:rtype: str
|
||||
"""
|
||||
dic = parser().parse(formula)
|
||||
return ''.join(c+str(dic[c]) if dic[c] != 1 else c for c in sorted(dic.keys()))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
li = ["K4(ON(SO3)2)2","Mg(OH)2"]
|
||||
sol = Solution()
|
||||
for s in li:
|
||||
print('>>>',s)
|
||||
print(sol.countOfAtoms(s))
|
||||
```
|
||||
|
||||
## [花括号展开2](https://leetcode-cn.com/problems/brace-expansion-ii/)
|
||||
### 题目
|
||||
如果你熟悉 Shell 编程，那么一定了解过花括号展开，它可以用来生成任意字符串。
|
||||
|
||||
花括号展开的表达式可以看作一个由 花括号、逗号 和 小写英文字母 组成的字符串，定义下面几条语法规则：
|
||||
|
||||
如果只给出单一的元素 x，那么表达式表示的字符串就只有 "x"。
|
||||
例如，表达式 {a} 表示字符串 "a"。
|
||||
而表达式 {ab} 就表示字符串 "ab"。
|
||||
当两个或多个表达式并列，以逗号分隔时，我们取这些表达式中元素的并集。
|
||||
例如，表达式 {a,b,c} 表示字符串 "a","b","c"。
|
||||
而表达式 {a,b},{b,c} 也可以表示字符串 "a","b","c"。
|
||||
要是两个或多个表达式相接，中间没有隔开时，我们从这些表达式中各取一个元素依次连接形成字符串。
|
||||
例如，表达式 {a,b}{c,d} 表示字符串 "ac","ad","bc","bd"。
|
||||
表达式之间允许嵌套，单一元素与表达式的连接也是允许的。
|
||||
```
|
||||
>>> {a,b}{c{d,e}}
|
||||
['acd', 'ace', 'bcd', 'bce']
|
||||
>>> {{a,z}, a{b,c}, {ab,z}}
|
||||
['a', 'ab', 'ac', 'z']
|
||||
>>> {a,b}c{d,e}f
|
||||
['acdf', 'acef', 'bcdf', 'bcef']
|
||||
```
|
||||
### 语法
|
||||
```
|
||||
expr -> item | item ',' expr
|
||||
item -> factor | factor item
|
||||
factor -> WORD | '{' expr '}'
|
||||
```
|
||||
|
||||
### 代码
|
||||
```python [brace-收起]
|
||||
```
|
||||
```python3 [brace-展开]
|
||||
import re
|
||||
from collections import namedtuple
|
||||
|
||||
token = namedtuple('token', ['type', 'value'])
|
||||
|
||||
|
||||
left = r'(?P<LEFT>\{)'
|
||||
right = r'(?P<RIGHT>\})'
|
||||
word = r'(?P<WORD>[a-z]+)'
|
||||
comma = r'(?P<COMMA>\,)'
|
||||
blank = r'(?P<BLANK>\s)'
|
||||
pt = re.compile('|'.join([left, right, word, comma, blank]))
|
||||
|
||||
|
||||
def genToken(s):
|
||||
scanner = pt.scanner(s)
|
||||
for i in iter(scanner.match, None):
|
||||
if i.lastgroup != 'BLANK':
|
||||
yield token(i.lastgroup, i.group(0))
|
||||
|
||||
|
||||
class parser:
|
||||
'''gramar
|
||||
expr -> item | item ',' expr
|
||||
item -> factor | factor item
|
||||
factor -> WORD | '{' expr '}'
|
||||
'''
|
||||
|
||||
def match(self, tp):
|
||||
# print(self.p.value)
|
||||
if tp == self.p.type:
|
||||
val = self.p.value
|
||||
try:
|
||||
self.p = next(self.gen)
|
||||
except StopIteration:
|
||||
self.p = None
|
||||
except Exception as e:
|
||||
print(e)
|
||||
return val
|
||||
else:
|
||||
raise Exception(f"[Error]: {tp} expected, got {self.p.type}")
|
||||
|
||||
def parse(self, s):
|
||||
self.gen = genToken(s)
|
||||
self.p = next(self.gen)
|
||||
st = self.expr()
|
||||
return sorted(list(st))
|
||||
|
||||
def expr(self):
|
||||
ret = self.item()
|
||||
while self.p and self.p.type == 'COMMA':
|
||||
self.match('COMMA')
|
||||
ret = ret.union(self.item())
|
||||
return ret
|
||||
|
||||
def item(self):
|
||||
ret = self.factor()
|
||||
while self.p and self.p.type in ['WORD', 'LEFT']:
|
||||
sufs = self.factor()
|
||||
new = set()
|
||||
for pre in ret:
|
||||
for suf in sufs:
|
||||
new.add(pre+suf)
|
||||
ret = new
|
||||
return ret
|
||||
|
||||
def factor(self):
|
||||
if self.p.type == 'LEFT':
|
||||
self.match('LEFT')
|
||||
ret = self.expr()
|
||||
self.match('RIGHT')
|
||||
return ret
|
||||
return {self.match('WORD')}
|
||||
|
||||
|
||||
class Solution:
|
||||
def braceExpansionII(self, expression):
|
||||
return parser().parse(expression)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
sol = Solution()
|
||||
li = ["{a,b}{c{d,e}}", "{{a,z}, a{b,c}, {ab,z}}", "{a,b}c{d,e}f"]
|
||||
for i in li:
|
||||
print('>>>', i)
|
||||
print(sol.braceExpansionII(i))
|
||||
```
|
||||
## [基本计算器4](https://leetcode-cn.com/problems/basic-calculator-iv/)
|
||||
### 题目
|
||||
给定一个表达式 expression 如 expression = "e + 8 - a + 5" 和一个求值映射，如 {"e": 1}（给定的形式为 evalvars = ["e"] 和 evalints = [1]），返回表示简化表达式的标记列表，例如 ["-1*a","14"]
|
||||
|
||||
表达式交替使用块和符号，每个块和符号之间有一个空格。
|
||||
块要么是括号中的表达式，要么是变量，要么是非负整数。
|
||||
块是括号中的表达式，变量或非负整数。
|
||||
变量是一个由小写字母组成的字符串（不包括数字）。请注意，变量可以是多个字母，并注意变量从不具有像 "2x" 或 "-x" 这样的前导系数或一元运算符 。
|
||||
表达式按通常顺序进行求值：先是括号，然后求乘法，再计算加法和减法。例如，expression = "1 + 2 * 3" 的答案是 ["7"]。
|
||||
|
||||
输出格式如下：
|
||||
|
||||
对于系数非零的每个自变量项，我们按字典排序的顺序将自变量写在一个项中。例如，我们永远不会写像 “b*a*c” 这样的项，只写 “a*b*c”。
|
||||
项的次数等于被乘的自变量的数目，并计算重复项。(例如，"a*a*b*c" 的次数为 4。)。我们先写出答案的最大次数项，用字典顺序打破关系，此时忽略词的前导系数。
|
||||
项的前导系数直接放在左边，用星号将它与变量分隔开 (如果存在的话)。前导系数 1 仍然要打印出来。
|
||||
格式良好的一个示例答案是 ["-2*a*a*a", "3*a*a*b", "3*b*b", "4*a", "5*c", "-6"] 。
|
||||
系数为 0 的项（包括常数项）不包括在内。例如，“0” 的表达式输出为 []。
|
||||
```
|
||||
>>> ((a - b) * (b - c) + (c - a)) * ((a - b) + (b - c) * (c - a)) [] []
|
||||
['-1*a*a*b*b', '2*a*a*b*c', '-1*a*a*c*c', '1*a*b*b*b', '-1*a*b*b*c', '-1*a*b*c*c', '1*a*c*c*c', '-1*b*b*b*c', '2*b*b*c*c', '-1*b*c*c*c', '2*a*a*b', '-2*a*a*c', '-2*a*b*b', '2*a*c*c', '1*b*b*b', '-1*b*b*c', '1*b*c*c', '-1*c*c*c', '-1*a*a', '1*a*b', '1*a*c', '-1*b*c']
|
||||
>>> e + 8 - a + 5 ['e'] [1]
|
||||
['-1*a', '14']
|
||||
```
|
||||
|
||||
### 语法
|
||||
```
|
||||
expr -> expr {'+'|'-'} term | term
|
||||
term -> term '*' item | item
|
||||
item -> num | var | '(' expr ')'
|
||||
```
|
||||
|
||||
### 代码
|
||||
|
||||
```python [cal-收起]
|
||||
```
|
||||
```python3 [cal-展开]
|
||||
import re
|
||||
from collections import namedtuple
|
||||
left = r'(?P<LEFT>\()'
|
||||
right = r'(?P<RIGHT>\))'
|
||||
var = r'(?P<VAR>[a-z]+)'
|
||||
num = r'(?P<NUM>\d+)'
|
||||
add = r'(?P<ADD>\+)'
|
||||
sub = r'(?P<SUB>\-)'
|
||||
mul = r'(?P<MUL>\*)'
|
||||
ws = r'(?P<WS> +)'
|
||||
pt = re.compile('|'.join([left, right, var, ws, num, add, sub, mul]))
|
||||
|
||||
token = namedtuple('token', ['type', 'value'])
|
||||
|
||||
|
||||
def genToken(s):
|
||||
scanner = pt.scanner(s)
|
||||
for i in iter(scanner.match, None):
|
||||
if i.lastgroup != 'WS':
|
||||
yield token(i.lastgroup, i.group(0))
|
||||
|
||||
|
||||
class parser(object):
|
||||
'''grammar
|
||||
expr -> expr {'+'|'-'} term | term
|
||||
term -> term '*' item | item
|
||||
item -> num | var | '(' expr ')'
|
||||
'''
|
||||
|
||||
def __init__(self, s, vars):
|
||||
self.token = [i for i in genToken(s)]
|
||||
self.lookahead = 0
|
||||
self.var = vars
|
||||
|
||||
def parse(self):
|
||||
dic = self.term()
|
||||
# terminate symbol
|
||||
while self.lookahead < len(self.token) and not self.isType('RIGHT'):
|
||||
assert self.isType('SUB', 'ADD')
|
||||
sign = 1 if self.match() == '+' else -1
|
||||
var = self.term()
|
||||
for i in var:
|
||||
if i in dic:
|
||||
dic[i] += var[i]*sign
|
||||
else:
|
||||
dic[i] = var[i]*sign
|
||||
return dic
|
||||
|
||||
def match(self, curType=None):
|
||||
sym = self.token[self.lookahead]
|
||||
# print(sym,curType)
|
||||
if curType is None or sym.type == curType:
|
||||
self.lookahead += 1
|
||||
return sym.value
|
||||
raise Exception('Invalid input string')
|
||||
|
||||
def isType(self, *s):
|
||||
sym = self.token[self.lookahead]
|
||||
return any(sym.type == i for i in s)
|
||||
|
||||
def term(self):
|
||||
li = []
|
||||
dic = self.item()
|
||||
while self.lookahead < len(self.token) and self.isType('MUL'):
|
||||
self.match()
|
||||
li.append(self.item())
|
||||
for d2 in li:
|
||||
newDic = {}
|
||||
for v1 in dic:
|
||||
for v2 in d2:
|
||||
s = ''
|
||||
if v1 == '':
|
||||
s = v2
|
||||
elif v2 == '':
|
||||
s = v1
|
||||
else:
|
||||
s = '*'.join(sorted(v1.split('*')+v2.split('*')))
|
||||
if s in newDic:
|
||||
newDic[s] += dic[v1]*d2[v2]
|
||||
else:
|
||||
newDic[s] = dic[v1]*d2[v2]
|
||||
dic = newDic
|
||||
return dic
|
||||
|
||||
def item(self):
|
||||
if self.isType('NUM'):
|
||||
return {'': int(self.match())}
|
||||
elif self.isType('VAR'):
|
||||
name = self.match()
|
||||
if name in self.var:
|
||||
return {'': self.var[name]}
|
||||
else:
|
||||
return {name: 1}
|
||||
elif self.isType('LEFT'):
|
||||
self.match()
|
||||
dic = self.parse()
|
||||
self.match('RIGHT')
|
||||
return dic
|
||||
else:
|
||||
print(self.token[self.lookahead])
|
||||
raise Exception('invalid string')
|
||||
|
||||
|
||||
class Solution:
|
||||
def basicCalculatorIV(self, expression, evalvars, evalints):
|
||||
"""
|
||||
:type expression: str
|
||||
:type evalvars: List[str]
|
||||
:type evalints: List[int]
|
||||
:rtype: List[str]
|
||||
"""
|
||||
self.var = dict(zip(evalvars, evalints))
|
||||
dic = parser(expression, self.var).parse()
|
||||
n = dic.pop('') if '' in dic else 0
|
||||
ret = []
|
||||
li = sorted(dic, key=lambda s: (-s.count('*'), s))
|
||||
for i in li:
|
||||
if dic[i] != 0:
|
||||
s = str(dic[i])
|
||||
ret.append(s + ('*'+i) if i else s)
|
||||
if n != 0:
|
||||
ret.append(str(n))
|
||||
return ret
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
sol = Solution()
|
||||
exprs = [
|
||||
"((a - b) * (b - c) + (c - a)) * ((a - b) + (b - c) * (c - a))", "e + 8 - a + 5"]
|
||||
names = [[], ["e"]]
|
||||
vars = [[], [1]]
|
||||
for i, j, k in zip(exprs, names, vars):
|
||||
print('>>>', i, j, k)
|
||||
print(sol.basicCalculatorIV(i, j, k))
|
||||
```
|
||||
|
||||
## 更多
|
||||
- [迷你语法分析器](https://leetcode-cn.com/problems/mini-parser/)
|
||||
- [字符串解码](https://leetcode-cn.com/problems/decode-string/)
|
||||
|
||||
|
|
@ -0,0 +1,86 @@
|
|||
import re
|
||||
from collections import namedtuple
|
||||
|
||||
token = namedtuple('token', ['type', 'value'])
|
||||
|
||||
|
||||
left = r'(?P<LEFT>\{)'
|
||||
right = r'(?P<RIGHT>\})'
|
||||
word = r'(?P<WORD>[a-z]+)'
|
||||
comma = r'(?P<COMMA>\,)'
|
||||
blank = r'(?P<BLANK>\s)'
|
||||
pt = re.compile('|'.join([left, right, word, comma, blank]))
|
||||
|
||||
|
||||
def genToken(s):
|
||||
scanner = pt.scanner(s)
|
||||
for i in iter(scanner.match, None):
|
||||
if i.lastgroup != 'BLANK':
|
||||
yield token(i.lastgroup, i.group(0))
|
||||
|
||||
|
||||
class parser:
|
||||
'''gramar
|
||||
expr -> item | item ',' expr
|
||||
item -> factor | factor item
|
||||
factor -> WORD | '{' expr '}'
|
||||
'''
|
||||
|
||||
def match(self, tp):
|
||||
# print(self.p.value)
|
||||
if tp == self.p.type:
|
||||
val = self.p.value
|
||||
try:
|
||||
self.p = next(self.gen)
|
||||
except StopIteration:
|
||||
self.p = None
|
||||
except Exception as e:
|
||||
print(e)
|
||||
return val
|
||||
else:
|
||||
raise Exception(f"[Error]: {tp} expected, got {self.p.type}")
|
||||
|
||||
def parse(self, s):
|
||||
self.gen = genToken(s)
|
||||
self.p = next(self.gen)
|
||||
st = self.expr()
|
||||
return sorted(list(st))
|
||||
|
||||
def expr(self):
|
||||
ret = self.item()
|
||||
while self.p and self.p.type == 'COMMA':
|
||||
self.match('COMMA')
|
||||
ret = ret.union(self.item())
|
||||
return ret
|
||||
|
||||
def item(self):
|
||||
ret = self.factor()
|
||||
while self.p and self.p.type in ['WORD', 'LEFT']:
|
||||
sufs = self.factor()
|
||||
new = set()
|
||||
for pre in ret:
|
||||
for suf in sufs:
|
||||
new.add(pre+suf)
|
||||
ret = new
|
||||
return ret
|
||||
|
||||
def factor(self):
|
||||
if self.p.type == 'LEFT':
|
||||
self.match('LEFT')
|
||||
ret = self.expr()
|
||||
self.match('RIGHT')
|
||||
return ret
|
||||
return {self.match('WORD')}
|
||||
|
||||
|
||||
class Solution:
|
||||
def braceExpansionII(self, expression):
|
||||
return parser().parse(expression)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
sol = Solution()
|
||||
li = ["{a,b}{c{d,e}}", "{{a,z}, a{b,c}, {ab,z}}", "{a,b}c{d,e}f"]
|
||||
for i in li:
|
||||
print('>>>', i)
|
||||
print(sol.braceExpansionII(i))
|
||||
|
|
@ -0,0 +1,134 @@
|
|||
import re
|
||||
from collections import namedtuple
|
||||
left = r'(?P<LEFT>\()'
|
||||
right = r'(?P<RIGHT>\))'
|
||||
var = r'(?P<VAR>[a-z]+)'
|
||||
num = r'(?P<NUM>\d+)'
|
||||
add = r'(?P<ADD>\+)'
|
||||
sub = r'(?P<SUB>\-)'
|
||||
mul = r'(?P<MUL>\*)'
|
||||
ws = r'(?P<WS> +)'
|
||||
pt = re.compile('|'.join([left, right, var, ws, num, add, sub, mul]))
|
||||
|
||||
token = namedtuple('token', ['type', 'value'])
|
||||
|
||||
|
||||
def genToken(s):
|
||||
scanner = pt.scanner(s)
|
||||
for i in iter(scanner.match, None):
|
||||
if i.lastgroup != 'WS':
|
||||
yield token(i.lastgroup, i.group(0))
|
||||
|
||||
|
||||
class parser(object):
|
||||
'''grammar
|
||||
expr -> expr {'+'|'-'} term | term
|
||||
term -> term '*' item | item
|
||||
item -> num | var | '(' expr ')'
|
||||
'''
|
||||
|
||||
def __init__(self, s, vars):
|
||||
self.token = [i for i in genToken(s)]
|
||||
self.lookahead = 0
|
||||
self.var = vars
|
||||
|
||||
def parse(self):
|
||||
dic = self.term()
|
||||
# terminate symbol
|
||||
while self.lookahead < len(self.token) and not self.isType('RIGHT'):
|
||||
assert self.isType('SUB', 'ADD')
|
||||
sign = 1 if self.match() == '+' else -1
|
||||
var = self.term()
|
||||
for i in var:
|
||||
if i in dic:
|
||||
dic[i] += var[i]*sign
|
||||
else:
|
||||
dic[i] = var[i]*sign
|
||||
return dic
|
||||
|
||||
def match(self, curType=None):
|
||||
sym = self.token[self.lookahead]
|
||||
# print(sym,curType)
|
||||
if curType is None or sym.type == curType:
|
||||
self.lookahead += 1
|
||||
return sym.value
|
||||
raise Exception('Invalid input string')
|
||||
|
||||
def isType(self, *s):
|
||||
sym = self.token[self.lookahead]
|
||||
return any(sym.type == i for i in s)
|
||||
|
||||
def term(self):
|
||||
li = []
|
||||
dic = self.item()
|
||||
while self.lookahead < len(self.token) and self.isType('MUL'):
|
||||
self.match()
|
||||
li.append(self.item())
|
||||
for d2 in li:
|
||||
newDic = {}
|
||||
for v1 in dic:
|
||||
for v2 in d2:
|
||||
s = ''
|
||||
if v1 == '':
|
||||
s = v2
|
||||
elif v2 == '':
|
||||
s = v1
|
||||
else:
|
||||
s = '*'.join(sorted(v1.split('*')+v2.split('*')))
|
||||
if s in newDic:
|
||||
newDic[s] += dic[v1]*d2[v2]
|
||||
else:
|
||||
newDic[s] = dic[v1]*d2[v2]
|
||||
dic = newDic
|
||||
return dic
|
||||
|
||||
def item(self):
|
||||
if self.isType('NUM'):
|
||||
return {'': int(self.match())}
|
||||
elif self.isType('VAR'):
|
||||
name = self.match()
|
||||
if name in self.var:
|
||||
return {'': self.var[name]}
|
||||
else:
|
||||
return {name: 1}
|
||||
elif self.isType('LEFT'):
|
||||
self.match()
|
||||
dic = self.parse()
|
||||
self.match('RIGHT')
|
||||
return dic
|
||||
else:
|
||||
print(self.token[self.lookahead])
|
||||
raise Exception('invalid string')
|
||||
|
||||
|
||||
class Solution:
|
||||
def basicCalculatorIV(self, expression, evalvars, evalints):
|
||||
"""
|
||||
:type expression: str
|
||||
:type evalvars: List[str]
|
||||
:type evalints: List[int]
|
||||
:rtype: List[str]
|
||||
"""
|
||||
self.var = dict(zip(evalvars, evalints))
|
||||
dic = parser(expression, self.var).parse()
|
||||
n = dic.pop('') if '' in dic else 0
|
||||
ret = []
|
||||
li = sorted(dic, key=lambda s: (-s.count('*'), s))
|
||||
for i in li:
|
||||
if dic[i] != 0:
|
||||
s = str(dic[i])
|
||||
ret.append(s + ('*'+i) if i else s)
|
||||
if n != 0:
|
||||
ret.append(str(n))
|
||||
return ret
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
sol = Solution()
|
||||
exprs = [
|
||||
"((a - b) * (b - c) + (c - a)) * ((a - b) + (b - c) * (c - a))", "e + 8 - a + 5"]
|
||||
names = [[], ["e"]]
|
||||
vars = [[], [1]]
|
||||
for i, j, k in zip(exprs, names, vars):
|
||||
print('>>>', i, j, k)
|
||||
print(sol.basicCalculatorIV(i, j, k))
|
||||
|
|
@ -0,0 +1,124 @@
|
|||
import re
|
||||
from collections import namedtuple
|
||||
left = r'(?P<LEFT>\()'
|
||||
right = r'(?P<RIGHT>\))'
|
||||
word = r'(?P<WORD>[a-z][a-z0-9]*)'
|
||||
num = r'(?P<NUM>(\-)?\d+)'
|
||||
blank = r'(?P<BLANK>\s+)'
|
||||
pt = re.compile('|'.join([left, right, word, num, blank]))
|
||||
|
||||
token = namedtuple('token', ['type', 'value'])
|
||||
|
||||
|
||||
def genToken(s):
|
||||
scanner = pt.scanner(s)
|
||||
for i in iter(scanner.match, None):
|
||||
if i.lastgroup != 'BLANK':
|
||||
yield token(i.lastgroup, i.group(0))
|
||||
|
||||
|
||||
class parser(object):
|
||||
'''grammar:
|
||||
S-> '(' expr ')'
|
||||
expr -> [mult|add] item item | let {word item } item
|
||||
item -> num | word| S
|
||||
'''
|
||||
|
||||
def config(self,s):
|
||||
if s:
|
||||
self.token = [i for i in genToken(s)]
|
||||
self.lookahead = 0
|
||||
self.vars = []
|
||||
|
||||
def parse(self, s):
|
||||
self.config(s)
|
||||
try:
|
||||
return self.S()
|
||||
except Exception as e:
|
||||
return e
|
||||
|
||||
def match(self, curType):
|
||||
sym = self.token[self.lookahead]
|
||||
if sym.type == curType:
|
||||
self.lookahead += 1
|
||||
return sym.value
|
||||
self.errorinfo(f'Expected {curType}, got {sym.value}')
|
||||
|
||||
def errorinfo(self, s, k=None):
|
||||
if k is None:
|
||||
k = self.lookahead
|
||||
pre = ' '.join([t.value for t in self.token[:k]])
|
||||
suf = ' '.join([t.value for t in self.token[k:]])
|
||||
print(pre+' '+suf)
|
||||
print(' '*(len(pre)+1)+'^'*len(self.token[k].value))
|
||||
raise Exception(s)
|
||||
|
||||
def readVar(self, var):
|
||||
for dic in self.vars[::-1]:
|
||||
if var in dic:
|
||||
return dic[var]
|
||||
self.errorinfo(f"Undefined varible '{var}'", self.lookahead-1)
|
||||
|
||||
def S(self):
|
||||
self.vars.append({})
|
||||
self.match('LEFT')
|
||||
ret = self.expr()
|
||||
self.match('RIGHT')
|
||||
self.vars.pop()
|
||||
return ret
|
||||
|
||||
def expr(self):
|
||||
op = self.match('WORD')
|
||||
if op == 'let':
|
||||
while self.token[self.lookahead].type != 'RIGHT':
|
||||
if self.token[self.lookahead].type == 'WORD':
|
||||
var = self.match('WORD')
|
||||
if self.token[self.lookahead].type == 'RIGHT':
|
||||
return self.readVar(var)
|
||||
else:
|
||||
self.vars[-1][var] = self.item()
|
||||
else:
|
||||
return self.item()
|
||||
elif op in {'mult', 'add'}:
|
||||
a = self.item()
|
||||
b = self.item()
|
||||
if op == 'mult':
|
||||
return a*b
|
||||
elif op == 'add':
|
||||
return a+b
|
||||
else:
|
||||
self.errorinfo('Unknown keyword', self.lookahead-1)
|
||||
|
||||
def item(self):
|
||||
if self.token[self.lookahead].type == 'WORD':
|
||||
return self.readVar(self.match('WORD'))
|
||||
elif self.token[self.lookahead].type == 'NUM':
|
||||
return int(self.match('NUM'))
|
||||
else:
|
||||
return self.S()
|
||||
|
||||
|
||||
class Solution(object):
|
||||
def evaluate(self, expression: str) -> int:
|
||||
return parser().parse(expression)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sol = Solution()
|
||||
|
||||
exprs = ['(add -1 2)',
|
||||
'(let x -2 y x y)',
|
||||
'(mult 3 (add 2 3))',
|
||||
'(let x 2 (mult x 5))',
|
||||
'(let x 2 (mult x (let x 3 y 4 (add x y))))',
|
||||
'(let x 2 x 3 x)',
|
||||
'(let x 2 (add (let x 3 (let x 4 x)) x))',
|
||||
'(let a1 3 b2 (add a1 1) b2)',
|
||||
'add 1 2)', # wrongs
|
||||
'(asd 1 2)',
|
||||
'(let a 1 b)',
|
||||
'(let a 1 b 2)'
|
||||
]
|
||||
for e in exprs:
|
||||
print('>>>', e)
|
||||
print(sol.evaluate(e))
|
||||
|
|
@ -0,0 +1,81 @@
|
|||
import re
|
||||
from collections import namedtuple
|
||||
left = r'(?P<LEFT>\()'
|
||||
right = r'(?P<RIGHT>\))'
|
||||
word = r'(?P<WORD>[A-Z][a-z]*)'
|
||||
num = r'(?P<NUM>\d+)'
|
||||
pt = re.compile('|'.join([left, right, word, num]))
|
||||
|
||||
token = namedtuple('token', ['type', 'value'])
|
||||
|
||||
|
||||
def genToken(s):
|
||||
scanner = pt.scanner(s)
|
||||
for i in iter(scanner.match, None):
|
||||
yield token(i.lastgroup, i.group(0))
|
||||
|
||||
|
||||
class parser:
|
||||
'''grammar:
|
||||
S-> item | S item
|
||||
item -> word | word num | '(' S ')' num
|
||||
'''
|
||||
|
||||
def match(self, curType):
|
||||
sym = self.token[self.lookahead]
|
||||
if sym.type == curType:
|
||||
self.lookahead += 1
|
||||
return sym.value
|
||||
raise Exception('Invalid input string')
|
||||
|
||||
def parse(self, s):
|
||||
self.token = [i for i in genToken(s)]
|
||||
self.lookahead = 0
|
||||
return self.S()
|
||||
def S(self):
|
||||
dic = {}
|
||||
while self.lookahead < len(self.token) and self.token[self.lookahead].type != 'RIGHT':
|
||||
cur = self.item()
|
||||
for i in cur:
|
||||
if i in dic:
|
||||
dic[i] += cur[i]
|
||||
else:
|
||||
dic[i] = cur[i]
|
||||
return dic
|
||||
|
||||
def item(self):
|
||||
if self.token[self.lookahead].type == 'WORD':
|
||||
ele = self.match('WORD')
|
||||
n = 1
|
||||
if self.lookahead < len(self.token) and self.token[self.lookahead].type == 'NUM':
|
||||
n = int(self.match('NUM'))
|
||||
return {ele: n}
|
||||
elif self.token[self.lookahead].type == 'LEFT':
|
||||
self.match('LEFT')
|
||||
dic = self.S()
|
||||
self.match('RIGHT')
|
||||
n = int(self.match("NUM"))
|
||||
for i in dic:
|
||||
dic[i] *= n
|
||||
return dic
|
||||
else:
|
||||
print(self.token[self.lookahead])
|
||||
raise Exception('invalid string')
|
||||
|
||||
|
||||
class Solution(object):
|
||||
def countOfAtoms(self, formula):
|
||||
"""
|
||||
:type formula: str
|
||||
:rtype: str
|
||||
"""
|
||||
dic = parser().parse(formula)
|
||||
return ''.join(c+str(dic[c]) if dic[c] != 1 else c for c in sorted(dic.keys()))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
li = ["K4(ON(SO3)2)2","Mg(OH)2"]
|
||||
sol = Solution()
|
||||
for s in li:
|
||||
print('>>>',s)
|
||||
print(sol.countOfAtoms(s))
|
||||
Loading…
Reference in New Issue