python写算法题：leetcode: 44. Wildcard Matching

class Solution(object):
    def fullMatch(self, s, p):
        if len(s)!=len(p): return False
        for i in xrange(len(s)):
            if s[i]!=p[i] and p[i]!='?':
                return False
        return True
    
    def endMatch(self, s, p):
        if len(s)>len(p):
            remain=s[:len(s)-len(p)]
        else:
            remain=""
        return remain, self.fullMatch(s[len(s)-len(p):], p)

    def startMatch(self, s, p):
        if len(s)>len(p):
            remain=s[:len(p)]
        else:
            remain=""
        remain=s[len(p):]
        return remain, self.fullMatch(s[:len(p)], p)
    
    def contain(self, s, p):
        pos=s.find(p)
        if pos>=0:
            remain=s[pos+len(p):]
            return remain, pos>=0
        else:
            return "", False
    
    def contains(self, s, ps):
        for p in ps:
            subps = p.split('?')
            if len(subps)>1:
                while True:
                    if len(s)<len(subps[0])+1:
                        return False
                    if len(subps[0])>0:
                        s1, ret=self.contain(s, subps[0])
                        if ret and len(s1)>0:
                            s1=s1[1:]
                        else:
                            ret = False
                    else:
                        s1, ret=s[1:], True
                    if ret:
                        for subp in subps[1:-1]:
                            if len(s1)<len(subp)+1:
                                ret=False
                                break
                            if len(subp)>0:
                                s1, ret=self.startMatch(s1[1:],subp)
                            else:
                                s1, ret=s1[1:], True
                            if not ret: 
                                break
                            
                    if ret:
                        s1, ret=self.startMatch(s1,subps[-1])
                    if ret: 
                        s=s1
                        break
                    pos=s.find(subps[0])
                    if pos==-1:
                        return False
                    s=s[pos+1:]
            else:
                pos=s.find(p)
                if pos>=0:
                    s=s[pos+len(p):]
                else:
                    return False
        return True
        
    def isMatch(self, s, p):
        subp=p.split('*')
        if len(subp) == 1: 
            return self.fullMatch(s,p)
        if subp[0]>0:
            s, ret = self.startMatch(s, subp[0])
            if not ret: 
                return False
        if subp[-1]>0:
            s, ret = self.endMatch(s, subp[-1])
            if not ret: 
                return False
        if len(subp)>2:
            return self.contains(s,subp[1:len(subp)-1])
        return True

吐血，教科书上的三行递归写法不好使，只能把递归展开成不同case处理，各种判断借助测试用例一点点改对的。