打卡帖 告别拖延症～

每日总结

1. python 的 super 模版 要加 super（）
2. python read inline

class Person:
        def __init__(self, firstName, lastName, idNumber):
                self.firstName = firstName
                self.lastName = lastName
                self.idNumber = idNumber
        def printPerson(self):
                print("Name:", self.lastName + ",", self.firstName)
                print("ID:", self.idNumber)

class Student(Person):
    #   Class Constructor
    #   
    #   Parameters:
    #   firstName - A string denoting the Person's first name.
    #   lastName - A string denoting the Person's last name.
    #   id - An integer denoting the Person's ID number.
    #   scores - An array of integers denoting the Person's test scores.
    #
    # Write your constructor here
    def __init__(self, firstname, lastName, id, scores):
        super().__init__(firstName, lastName, id)
        self.scores = scores
   

    #   Function Name: calculate
    #   Return: A character denoting the grade.
    #
    # Write your function here
    def calculate(self):
        scores = self.scores
        if len(scores) == 0:
            return 'T'
        score = sum(scores) / len(scores)
        if 90 <= score <= 100:
            return 'O'
        if 80 <= score < 90:
            return 'E'
        if 70 <= score < 80:
            return 'A'
        if 55 <= score < 70:
            return 'P'
        if 40 <= score < 55:
            return 'D'
        if score < 40:
            return 'T'
        

line = input().split()
firstName = line[0]
lastName = line[1]
idNum = line[2]
numScores = int(input()) # not needed for Python
scores = list( map(int, input().split()) )
s = Student(firstName, lastName, idNum, scores)
s.printPerson()
print("Grade:", s.calculate())

line = input().split()
firstName = line[0]
lastName = line[1]
idNum = line[2]
scores = list(map(int, input().split()))
s = Student(firstName, lastName, idNum, scores)
s.printPerson
print("Grade: ", s.calculate())

class Solution:
    def trimBST(self, root: TreeNode, low: int, high: int) -> TreeNode:
        
        def trim(node):
            if node is None:
                return None
            elif node.val > high:
                return trim(node.left)
            elif node.val < low:
                return trim(node.right)
            else:
                node.left = trim(node.left)
                node.right = trim(node.right)
               
                # what should i return here
                return node
            
        return trim(root)
               
Leetcode 669
递归：
一般binary search tree都是recursion
然后用subfunction的时候用node不用root
最后用root call一次这个function
还是要理解recursion的精髓。。

lintcode

    def hasCycle(self, head):
        # write your code here
        if head is None:
            return False

        fast = slow = head

        while fast != None:
            if fast.next is None:
                return False

            # there is a cycle since fast already catches up with slow
            if fast.next == slow:
                return True

            # we need to make sure fast.next is not None
            # so we will not get None.next
            fast =  fast.next.next
            slow = slow.next

        return False

Since we need to make sure fast.next is never None, if not , we will get into trouble like

"None.next"

1: handling input and output
2: Set -> add   set([list])
3. queue -> append

    arr = list(map(int, input().rstrip().split()))
    arr = arr[::-1]
    arr = ' '.join(str(x) for x in arr)
    #print(' '.join(arr))
    print(arr)


    # .join() only joins strings list
    # you can do line 8 if you want to join integer list


    intervals = sorted(intervals, keys = lambda interval: interval.start)

    # this is template for lambda sort

今天小目标：模版总结完

dict, set, queue, list - 括号的问题 哪种括号，加在哪里

今日dict: https://www.geeksforgeeks.org/deque-in-python/

break continue pass https://www.geeksforgeeks.org/py ... ords-python/?ref=rp

- [ ] strings/arrays
- [ ] sliding window
- [ ] prefix sums
- [ ] binary search
- [ ] heap
- [ ] trie
- [ ] dynamic programming
- [ ] topological sort
- [ ] tree traversal recursion
- [ ] bfs
- [ ] dfs

del dict['item']

Toreview:
break continue
lambda, map, filter

list.remove(element)

pass in copy: original[:]

def example(self, animal = 'Dog', name = None, *toppings, **user_info)
# for default value and optional argument
# * toppings an arbitrary number of arguments
# ** user_info, an arbitrary number of keyword argument
# come in as dictionary
for key, value in user_info.items():
profile[key] = value

inheritance:

super().__init__(name)

b.sort(reverse = True) # sort a list
print(sorted(b)) # sort a list temporarily
b.reverse()