9/17 fb刷题：二进制求和，二叉树验证，随机选择最大数，反转链表，回文字符，二分法，task schedule

二进制求和：

class Solution:
    def addBinary(self, a: str, b: str) -> str:
        lengtha = len(a)
        lengthb = len(b)
        if lengtha > lengthb:
            b = (lengtha -lengthb)*'0'+b
        else:
            a = (lengthb - lengtha)*'0'+a
        length = len(a)
        print (a,b)
        out = 0
        res = ""
        for i in range(length-1,-1,-1):
            print("i",i)
            result = ord(a[i])- ord('0')+ord(b[i])- ord('0') +out
            if result >= 2:
                print(result)
                res = str(result - 2) + res
                out = 1
                print("i" ,res)
            else:
                res = str(result) +res
                out = 0
        if out == 1:
            res = '1' + res
        return res

 

Validate binary tree:

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def isValidBST(self, root: Optional[TreeNode]) -> bool:
        minval = - 2**31 -1
        maxval = 2**31 
        return self.isValidhelper(root.left, minval, root.val) and self.isValidhelper(root.right,root.val,maxval)
    def isValidhelper(self,root, minval,maxval):
        if not root:
            return True
        if root.val <= minval or root.val >= maxval:
            return False
        return self.isValidhelper(root.left, minval, root.val) and self.isValidhelper(root.right,root.val,maxval)

反转链表

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
        if not head or not head.next:
            return head
        prev, cur, nextnode = None, head, head.next
        while nextnode:
            cur.next = prev
            prev = cur 
            cur = nextnode
            nextnode = nextnode.next
        cur.next = prev
        return cur

随机选择最大数：

注意：  生成随机数： random.randint(l,r)

class Solution:

    def __init__(self, nums: List[int]):
        self.nums = nums
    def pick(self, target: int) -> int:
        ansset = []
        for i in range(len(self.nums)):
            if self.nums[i] == target:
                ansset.append(i)
        x = random.randint(0,len(ansset)-1)
        return ansset[x]


# Your Solution object will be instantiated and called as such:
# obj = Solution(nums)
# param_1 = obj.pick(target)

 

判断是否是字母： str. isalpha()

判断是否是数字： str. isdigit()

变小写 str.lower()

 

class Solution:
    def isPalindrome(self, s: str) -> bool:
        ans = ""
        for char in s:
            if char.isalpha() or char.isdigit():
                ans += char.lower()
        return ans == ans[::-1]

  

二分法判断：

# The isBadVersion API is already defined for you.
# @param version, an integer
# @return an integer
# def isBadVersion(version):

class Solution:
    def firstBadVersion(self, n):
        """
        :type n: int
        :rtype: int
        """
        low, high = 0, n-1
        while (low <= high):
            middle = (low+high) //2
            if isBadVersion(middle):
                high = middle
                if high == low:
                    return low
            else:
                low = middle + 1
        return low
                
            
        

字典counter 相关的另一应用：

可以直接转换，不用遍历了

#对列表作用
list_01 = [1,9,9,5,0,8,0,9]  #GNZ48-陈珂生日
print(Counter(list_01))  #Counter({9: 3, 0: 2, 1: 1, 5: 1, 8: 1})
 
#对字符串作用
temp = Counter('abcdeabcdabcaba')
print(temp)  #Counter({'a': 5, 'b': 4, 'c': 3, 'd': 2, 'e': 1})
#以上其实是两种使用方法，一种是直接用，一种是实例化以后使用,如果要频繁调用的话，显然后一种更简洁

应用： task scheduler

 

class Solution:
    def leastInterval(self, tasks: List[str], n: int) -> int:
        length = len(tasks)
        temp  = list(Counter(tasks).values())
        maxct = max(temp)
        elemaxct = temp.count(maxct)
        return max(length,(maxct-1)*(n+1)+elemaxct)