百姓网那道题

赖勇浩（http://laiyonghao.com）

 

昨天 @smallfish 传了个网址（http://home.wangjianshuo.com/cn/20100505_ccceeieeaece.htm）给我，打开一看，是王建硕先生的博客，正好我前段时间经由阮一峰的博客看到过他的简介，就好奇他又写了啥。仔细一看，原来是出了一道公开的笔试题，蛮有意思的，就决心做做看。

一开始看到要支持 AND OR 等逻辑操作符，想来也要支持括号标明优先级了，就想到拿前几天 python-cn 社区介绍的 PLY 模块做个 parser。虽然是第一次用这个模块，但真的很好用，写 parser 用的时间很短，调试了几下，就能够支持比较复杂的表达式了，比如：

(age < 15 and sex == 0) or age > 30

整出来的语法树如下：
or
  and
    ('<', 'age', 15)
    ('==', 'sex', 0)
  ('>', 'age', 30)

接下来在比较两棵树是否有子集关系的时候，遇到了问题。今天早上看到 qmigh（http://qmigh.blogspot.com/）的想法，启发了我。不过他提出的方案是把查询表达式“规范化”，这一步是比较难做的，需要用到离散数学的一些知识，实现起来比较烦。我思考之后，发现“规范化”只是为了将语法树转成两层的或与树，想到这一点之后，就可以不进行“规范化”了，只要将与或树的特性应用到语法树中即可。具体的判断方案我在代码里以注释的形式写了出来。

本题的解决方案后面的知识，SeasonLee 有一篇文章写得清晰，可供参考：从离散数学到编译原理--百姓网编程题后序（http://www.cnblogs.com/SeasonLee/archive/2010/05/11/1731414.html）

现在这个方案可以实现比较复杂的表达式判断，不过不支持 NOT，也不支持 != 号，只支持 AND、OR、>、< 和 ==，可以使用 () 指定优先级。其实代码不长，约有 100 行是后面测试用的一些代码。

 

经王建硕先生同意，我把自己的方案公布到博客上，欢迎大家讨论和指正。

 

  1 # encoding:utf-8
  2
  3 try:
  4   from ply import yacc
  5   from ply import lex
  6 except ImportError:
  7   import sys
  8   print "Please install PLY first."
  9   print r"You can download it from here: http://www.dabeaz.com/ply/ply-3.3.tar.gz"
 10   sys.exit(1)
 11
 12 #############################################
 13 #                lex
 14 #############################################
 15
 16 # 定义条件表达式的词法
 17 tokens = ['FIELD', 'NUMBER', 'GT', 'EQ', 'LT', 'AND', 'OR', 'LPAREN', 'RPAREN']
 18
 19 t_ignore = ' /t'
 20 t_FIELD = r'(?!and)(?!or)[a-zA-Z_][a-zA-Z0-9_]*'
 21 t_GT = r'>'
 22 t_EQ = r'=='
 23 t_LT = r'<'
 24 t_AND = r'and'
 25 t_OR = r'or'
 26 t_LPAREN = r'/('
 27 t_RPAREN = r'/)'
 28
 29 def t_NUMBER(t):
 30   r'/d+'
 31   t.value = int(t.value)
 32   return t
 33
 34 def t_error(t):
 35   raise TypeError("Unknow text '%s'"%t.value)
 36
 37 lex.lex()
 38
 39 #############################################
 40 #                yacc
 41 #############################################
 42
 43 # 用 BNF 定义条件表达式的语法，支持 AND OR，以及 () 的嵌套
 44 def p_expr4(p):
 45   '''
 46   expr :
 47   '''
 48
 49 def p_expr3(p):
 50   '''
 51   expr : LPAREN expr RPAREN
 52   '''
 53   p[0] = p[2]
 54
 55 def p_expr2(p):
 56   '''
 57   expr : condi
 58   '''
 59   p[0] = p[1]
 60
 61 def p_expr(p):
 62   '''
 63   expr : expr logic_op expr
 64   '''
 65   p[0] = (p[2], p[1], p[3])
 66
 67 def p_logic_op(p):
 68   '''
 69   logic_op : AND
 70   logic_op : OR
 71   '''
 72   p[0] = p[1]
 73
 74 def p_condi(p):
 75   '''condi : FIELD cmp_op NUMBER'''
 76   p[0] = (p[2], p[1], p[3])
 77
 78 # for i in p:print i
 79
 80 def p_cmp_op(p):
 81   '''
 82   cmp_op : GT
 83   cmp_op : EQ
 84   cmp_op : LT
 85   '''
 86   p[0] = p[1]
 87   #for i in p:print i
 88
 89 def p_error(p):
 90         raise TypeError("unknow text at %s"%p.value)
 91
 92 yacc.yacc()
 93
 94 #############################################
 95 #                util
 96 #############################################
 97
 98 # 以比较漂亮的形式打印语法树
 99 INDENT = '  '
100 def print_tree(t, indent):
101   if not t:
102     print indent + str(t)
103     return
104   op, l, r = t
105   if op in ('and', 'or'):
106     print indent + op
107     print_tree(l, indent + INDENT)
108     print_tree(r, indent + INDENT)
109   else:
110     print indent + str(t)
111
112 #############################################
113 #                judge
114 #############################################
115 OP = ('>', '<', '==')
116 AND = 'and'
117 OR = 'or'
118
119 # 对 age < 18 和 age < 10 这种原子条件表达式对行判断
120 # 首先要求字段名要相同，否则返回 false
121 # 然后是根据表达式的比较运算符进行分情况比较
122 def is_subset_atom_atom(left, right):
123   assert left and right
124   lop, ll, lr = left
125   rop, rl, rr = right
126   assert lop in OP and rop in OP
127   if ll != rl:
128     return False
129   if lop == rop == '>':
130     return lr >= rr
131   elif lop == rop == '<':
132     return lr <= rr
133   elif lop == rop == '==':
134     return lr == rr
135   elif lop == '>':
136     return False
137   elif lop == '<':
138     return False
139   elif lop == '==':
140     if rop == '>':
141       return lr > rr
142     else: # '<'
143       return lr < rr
144   else:
145     raise RuntimeError('Error')
146
147 # 比较 age < 10 和 age < 10 and sex == 0 这种形式的复合表达式
148 # 这种情况下要求左式必须是右式的两个子式的子集才返回为 true
149 def is_subset_atom_and(left, right):
150   assert left and right
151   rop, rl, rr = right
152   global is_subset
153   return is_subset(left, rl) and is_subset(left, rr)
154
155 # 比较 age < 10 和 age < 10 or sex == 0 这种形式的复杂表达式
156 # 这种情况下只需要左式是右式中的任一子式的子集即返回 true
157 def is_subset_atom_or(left, right):
158   assert left and right
159   rop, rl, rr = right
160   global is_subset
161   return is_subset(left, rl) or is_subset(left, rr)
162
163 # 比较 age < 10 and sex == 0 和 age < 10 这种复合表达式
164 # 要求左式的任一子式为右式的子集即返回 true
165 def is_subset_and_atom(left, right):
166   assert left and right
167   lop, ll, lr = left
168   global is_subset
169   return is_subset(ll, right) or is_subset(lr, right)
170
171 # 比较 age < 10 and sex == 0 和 age < 18 and sex == 1 这种复合表达式
172 # 要求左式的任一子式必须都是右式的*某一*子式的子集才返回 true
173 def is_subset_and_and(left, right):
174   assert left and right
175   lop, ll, lr = left
176   rop, rl, rr = right
177   global is_subset
178   lresult = is_subset(ll, rl) or is_subset(ll, rr)
179   rresult = is_subset(lr, rl) or is_subset(lr, rr)
180   return lresult and rresult
181
182 # 比较 age < 10 and sex == 0 和 age < 10 or sex == 1 这种复合表达式
183 # 要求整个左式必须是右式的某一子式为真才返回 true
184 def is_subset_and_or(left, right):
185   assert left and right
186   lop, ll, lr = left
187   rop, rl, rr = right
188   global is_subset
189   return is_subset(left, rl) or is_subset(left, rr)
190
191 # 比较 age < 10 or sex == 0 和 age < 10 这种复合表达式
192 # 要求左式的任一子式都必须是右式的子集才返回 true
193 def is_subset_or_atom(left, right):
194   assert left and right
195   lop, ll, lr = left
196   global is_subset
197   return is_subset(ll, right) and is_subset(lr, right)
198
199 # 比较 age < 10 or sex == 0 和 age < 10 and sex == 0 这种复合表达式
200 # 与 is_subset_or_atom 是一样的。
201 def is_subset_or_and(left, right):
202   return is_subset_or_atom(left, right)
203
204 # 比较 age < 10 or sex == 0 和 age < 10 or sex == 0 这种复合表达式
205 # 与 is_subset_or_atom 是一样的。
206 def is_subset_or_or(left, right):
207   return is_subset_or_atom(left, right)
208
209 # 根据左右式的操作符分派给上述的判断函数
210 def is_subset(left, right):
211   assert left and right
212   print 'left:',left
213   print 'right:',right
214   lop, ll, lr = left
215   rop, rl, rr = right
216   if lop in OP:
217     if rop in OP:
218       return is_subset_atom_atom(left, right)
219     elif rop == AND:
220       return is_subset_atom_and(left, right)
221     elif rop == OR:
222       return is_subset_atom_or(left, right)
223     raise RuntimeError('Error')
224   elif lop == 'and':
225     if rop in OP:
226       return is_subset_and_atom(left, right)
227     elif rop == AND:
228       return is_subset_and_and(left, right)
229     elif rop == OR:
230       return is_subset_and_or(left, right)
231     else:
232       raise RuntimeError('Error')
233   elif lop == 'or':
234     if rop in OP:
235       return is_subset_or_atom(left, right)
236     elif rop == AND:
237       return is_subset_or_and(left, right)
238     elif rop == OR:
239       return is_subset_or_or(left, right)
240     else:
241       raise RuntimeError('Error')
242   else:
243     raise RuntimeError('Error')
244
245 #############################################
246 #                query
247 #############################################
248 class Query(object):
249   def __init__(self, q):
250     self._q = q
251     self._tree = yacc.parse(q)
252     assert self._tree
253     
254   def is_subset(self, other):
255     if not self._tree:
256       return False
257     if not other._tree:
258       return True
259     return is_subset(self._tree, other._tree)
260
261 #############################################
262 #                test
263 #############################################
264 if __name__ == '__main__':
265   t0 = Query('age > 40') # 中年人
266   t1 = Query('age > 18') # 成年人
267   print t0.is_subset(t0)
268   print t0.is_subset(t1)
269   print t1.is_subset(t0)
270   print t1.is_subset(t1)
271   print '-'*30
272   
273   t2 = Query('age > 18 and weight < 100') # 成年瘦子
274   t3 = Query('age > 18 or weight < 100') # 成年人，或体重小于 100
275   print t0.is_subset(t2)
276   print t0.is_subset(t3)
277
278   print t2.is_subset(t0)
279   print t2.is_subset(t3)
280   
281   print t3.is_subset(t2)
282
283   r0 = Query('age > 30 and sex == 0')
284   r1 = Query('age > 40 and sex == 0')
285
286   print r0.is_subset(r1)
287   print r1.is_subset(r0)
288   print '='*30
289   
290   t0 = Query('(age < 15 and sex == 0) or age > 30')
291   t1 = Query('age < 7')
292   t2 = Query('age < 18')
293   print_tree(t0._tree, '')
294   print '*'*30
295   assert 't0 is subset of t0:' and t0.is_subset(t0) == True
296   print '-'*30
297   assert 't0 is subset of t1:' and t0.is_subset(t1) == False
298   print '-'*30
299   assert 't1 is subset of t0:' and t1.is_subset(t0) == False
300   print '-'*30
301   assert 't2 is subset of t0:' and t2.is_subset(t0) == False
302   print '-'*30
303   
304   q0 = Query('age < 15')
305   q1 = Query('age > 30')
306   q2 = Query('age > 18')
307   q3 = Query('age > 40')
308   q4 = Query('age > 30 and sex == 0')
309   
310
311   assert 'q0 is subset of q0:' and q0.is_subset(q0) == True
312   print '-'*30
313   assert 'q0 is subset of q1:' and q0.is_subset(q1) == False
314   print '-'*30
315   assert 'q0 is subset of q2:' and q0.is_subset(q2) == False
316   print '-'*30
317   assert 'q0 is subset of q3:' and q0.is_subset(q3) == False
318   print '-'*30
319   assert 'q0 is subset of q4:' and q0.is_subset(q4) == False
320   print '-'*30
321   print
322
323   assert 'q1 is subset of q0:' and q1.is_subset(q0) == False
324   print '-'*30
325   assert 'q1 is subset of q1:' and q1.is_subset(q1) == True
326   print '-'*30
327   assert 'q1 is subset of q2:' and q1.is_subset(q2) == True
328   print '-'*30
329   assert 'q1 is subset of q3:' and q1.is_subset(q3) == False
330   print '-'*30
331   assert 'q1 is subset of q4:' and q1.is_subset(q4) == False
332   print '-'*30
333   print
334
335   assert 'q2 is subset of q0:' and q2.is_subset(q0) == False
336   print '-'*30
337   assert 'q2 is subset of q1:' and q2.is_subset(q1) == False
338   print '-'*30
339   assert 'q2 is subset of q2:' and q2.is_subset(q2) == True
340   print '-'*30
341   assert 'q2 is subset of q3:' and q2.is_subset(q3) == False
342   print '-'*30
343   assert 'q2 is subset of q4:' and q2.is_subset(q4) == False
344   print '-'*30
345   print
346
347   assert 'q3 is subset of q0:' and q3.is_subset(q0) == False
348   print '-'*30
349   assert 'q3 is subset of q1:' and q3.is_subset(q1) == True
350   print '-'*30
351   assert 'q3 is subset of q2:' and q3.is_subset(q2) == True
352   print '-'*30
353   assert 'q3 is subset of q3:' and q3.is_subset(q3) == True
354   print '-'*30
355   assert 'q3 is subset of q4:' and q3.is_subset(q4) == False
356   print '-'*30
357   print
358
359   assert 'q4 is subset of q0:' and q4.is_subset(q0) == False
360   print '-'*30
361   assert 'q4 is subset of q1:' and q4.is_subset(q1) == True
362   print '-'*30
363   assert 'q4 is subset of q2:' and q4.is_subset(q2) == True
364   print '-'*30
365   assert 'q4 is subset of q3:' and q4.is_subset(q3) == False
366   print '-'*30
367   assert 'q4 is subset of q4:' and q4.is_subset(q4) == True
368   print '-'*30
369
370