leetcode刷题记录（十三）

def hasCycle(self, head):
        """
        :type head: ListNode
        :rtype: bool
        """
        if head == None:
            return False
        m1 = head
        m2 = head.next
        while m2 != None and m2.next != None:
            m1 = m1.next
            m2 = m2.next.next
            if m2 is m1:
                return True
        return False

one, two = 0, 0
        for x in nums:
            one, two, three = one ^ x, two | (one & x), two & x
            one, two = one & ~three, two & ~three
        return one

if not nums: return 0
        l = len(nums)
        if l <=1 : return 1
        res = 1
        max1 = 1
        for i in range(1,l):
            if i and nums[i-1] < nums[i]:
                res +=1
                if res > max1:
                    max1 = res
            else:
                res = 1
        return max1

a = []
        for i in A:
            if i not in a:
                a += [i]
            else:
                return i

for i in xrange(len(nums)):
            index = abs(nums[i]) - 1
            nums[index] = -abs(nums[index])
        return [index for index,n in enumerate(nums,start=1) if n > 0]

def binaryTreePaths(self, root):
        """
        :type root: TreeNode
        :rtype: List[str]
        """
        if not root: return []
        if not root.left and not root.right:
            return [str(root.val)]
        return [str(root.val)+'->'+i for i in self.binaryTreePaths(root.left)] + [str(root.val) + '->' + i for i in self.binaryTreePaths(root.right)]

curA, curB = headA, headB
        lenA,lenB = 0,0
        while curA:
            lenA += 1
            curA = curA.next
        while curB:
            lenB += 1
            curB = curB.next
        curA, curB = headA, headB
        if lenA >= lenB:
            for i in range(abs(lenA-lenB)):
                curA = curA.next
        else:
            for i in range(abs(lenA-lenB)):
                curB = curB.next
        while curB != curA:
            curA,curB = curA.next,curB.next
        return curA

l = 0
       r = len(nums) - 1
       
       while l < r:
           mid = (r+l)/2
           if nums[mid]>nums[mid+1] and nums[mid] > nums[mid-1]:
               return mid
           if nums[mid] < nums[mid + 1]:
               l = mid + 1
           else:
               r = mid - 1
       return l

if head == None:
            return head
        cur = head.next
        pre = head
        
        while cur != None:
            if cur.val == pre.val:
                pre.next = cur.next
                cur = cur.next
            else:
                cur = cur.next
                pre = pre.next
        return head

def minutes(p):
           h,m = map(int,p.split(':'))
           return 60*h+m
       
       mins = sorted(map(minutes,timePoints))
       mins.append(60*24 + mins[0])
       return min(b-a for a,b in zip(mins,mins[1:]))

sort = sorted(nums)[::-1]
        rank = ["Gold Medal", "Silver Medal", "Bronze Medal"]+map(str,range(4,len(nums)+1))
        return map(dict(zip(sort,rank)).get,nums)

def shrink(num):
    a = len(num)
    for i in range(a - 1):
        if num[i] > num[i+1]:
            return num[:i]+num[i+1:]
for i in range(k):
    num = shrink(num)
return str(int(num)) if num else "0"

self.sum = 0
        def dfs(root):
            if root:
                if root.left and not root.left.left and not root.left.right:
                    self.sum += root.left.val
                dfs(root.left)
                dfs(root.right)
        dfs(root)
        return self.sum