Ubuntu中文论坛

代码： 全选

import string
atom_alphabet = list(string.ascii_lowercase)
operator_alphabet = ['<->','!','&&','||','->','(',')']
alphabet = operator_alphabet + atom_alphabet

def explaintion_generator(atom_list):
    if len(atom_list) == 0:
        yield {}
    else:
        for i in explaintion_generator(atom_list[:-1]):
            i[atom_list[-1]] = False
            yield i
            i[atom_list[-1]] = True
            yield i
    def __str__(self):
        pass

class exp:
    def evaluate(self,explaintion):
        pass
    def print_value_table(self,atom_parentheseslist):
        import sys
        sys.stdout.write('N')
        for i in atom_list:
            sys.stdout.write('\t' + i)
        sys.stdout.write('\t' + str(self) + '\n')
        n = 0
        for i in explaintion_generator(atom_list):
            sys.stdout.write(str(n))
            n += 1 
            for j in atom_list:
                sys.stdout.write('\t' + str(i[j]))
            sys.stdout.write('\t' + str(self.evaluate(i)) + '\n')

class orexp(list,exp):
    def __str__(self):
        return '(' + ' || '.join([str(i) for i in self]) + ')'
    def evaluate(self,explaintion):
        res = False
        for i in self:
            res = res or i.evaluate(explaintion)
            if res:
                return res
        return res

class andexp(list,exp):
    def __str__(self):
        return '(' + ' && '.join([str(i) for i in self]) + ')'
    def evaluate(self,explaintion):
        res = True
        for i in self:
            res = res and i.evaluate(explaintion)
            if not res:
                return res
        return res

class eqexp(exp):
    def __init__ (self,l,r):
        self.l = l
        self.r = r
    def __str__(self):
        return '(' + str(self.l) + ' <-> ' + str(self.r) + ')'
    def evaluate(self,explaintion):
        l = self.l.evaluate(explaintion)
        r = self.r.evaluate(explaintion)
        return l == r

class impexp(exp):
    def __init__ (self,l,r):
        self.l = l
        self.r = r
    def __str__(self):
        return '(' + str(self.l) + ' -> ' + str(self.r) + ')'
    def evaluate(self,explaintion):
        l = self.l.evaluate(explaintion)
        r = self.r.evaluate(explaintion)
        return ( not l ) or r

class notexp(exp):
    def __init__ (self,e):
        self.e = e
    def __str__(self):
        return '!' + str(self.e) 
    def evaluate(self,explaintion):
        return not self.e.evaluate(explaintion)

class atomexp(exp,str):
    def __str__ (self):
        return str.__str__(self)
    def evaluate(self,explaintion):
        return explaintion[str(self)]

class holding_iter(object):
    def __init__ (self,s):
        self.i = iter(s)
        self.now = ''
    def next (self):
        self.now = ''
        while not (self.now in alphabet):
            t = self.i.next()
            if not t in string.whitespace:
                self.now += t
        return self.now

def parseexp0(i): #or
    e = parseexp1(i)
    if i.now == '||':
        ore = orexp()
        ore.append(e)
        while i.now == '||':
            i.next()
            e = parseexp1(i)
            ore.append(e)
        return ore
    else :
        return e

def parseexp1(i): #and
    e = parseexp2(i)
    if i.now == '&&':
        ande = andexp()
        ande.append(e)
        while i.now == '&&':
            i.next()
            e = parseexp2(i)
            ande.append(e)
        return ande
    else :
        return e

def parseexp2(i): #imply
    e = parseexp3(i)
    if i.now == '->':
        i.next()
        e2 = parseexp3(i)
        return impexp(e,e2)
    else:
        return e

def parseexp3(i): #equal
    e = parseexp4(i)
    if i.now == '<->':
        i.next()
        e2 = parseexp4(i)
        return eqexp(e,e2)
    else:
        return e

def parseexp4(i): #not
    if i.now == '!':
        i.next()
        return notexp(parseexp4(i))
    else:
        return parseexp5(i)

def parseexp5(i): #atom
    if i.now in atom_alphabet:
        e = atomexp(i.now)
        try:
            i.next()
        except StopIteration:
            return e
        return e
    else:
        return parseexp6(i)

def parseexp6(i): #parentheses
    if i.now == '(':
        i.next()
        e = parseexp0(i)
        if i.now == ')':
            try:
                i.next()
            except StopIteration:
                return e
            return e
        else:
            raise Exception('error while parsing expression string.')
    else:
            raise Exception('error while parsing expression string.')

if __name__ == '__main__':
#s = '(p->q) && (s||t) && ((q&&!r) || (!q&&r)) && (r<->s) && (t -> (p&&q))'
    import sys
    s = sys.argv[1]
    atom_list = []
    i = holding_iter(s)
    while True:
        try:
            j = i.next()
        except StopIteration:
            break
        if j in atom_alphabet and ( not j in atom_list ):
            atom_list.append(j)
    atom_list.sort()

    i = holding_iter(s)
    i.next()
    a = parseexp0(i)
    # print a
    a.print_value_table(atom_list)

代码： 全选

$ python a.py '(p->q) && (s||t) && ((q&&!r) || (!q&&r)) && (r<->s) && (t -> (p&&q))'
N       p       q       r       s       t       ((p -> q) && (s || t) && ((q && !r) || (!q && r)) && (r <-> s) && (t -> (p && q)))
0       False   False   False   False   False   False
1       False   False   False   False   True    False
2       False   False   False   True    False   False
3       False   False   False   True    True    False
4       False   False   True    False   False   False
5       False   False   True    False   True    False
6       False   False   True    True    False   True
7       False   False   True    True    True    False
8       False   True    False   False   False   False
9       False   True    False   False   True    False
10      False   True    False   True    False   False
11      False   True    False   True    True    False
12      False   True    True    False   False   False
13      False   True    True    False   True    False
14      False   True    True    True    False   False
15      False   True    True    True    True    False
16      True    False   False   False   False   False
17      True    False   False   False   True    False
18      True    False   False   True    False   False
19      True    False   False   True    True    False
20      True    False   True    False   False   False
21      True    False   True    False   True    False
22      True    False   True    True    False   False
23      True    False   True    True    True    False
24      True    True    False   False   False   False
25      True    True    False   False   True    True
26      True    True    False   True    False   False
27      True    True    False   True    True    False
28      True    True    True    False   False   False
29      True    True    True    False   True    False
30      True    True    True    True    False   False
31      True    True    True    True    True    False