百姓网那道题

赖勇浩（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