1
2
3
4

class Solution:
    def sum(self, num1: int, num2: int) -> int:
        return num1 + num2
        

1
2
3
4
5
6
7
8
9
10

# 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 checkTree(self, root: Optional[TreeNode]) -> bool:
        return root.val == (root.left.val + root.right.val)
        

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

# 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 switch_node(self, node):
        tempNode = node.left
        node.left = node.right
        node.right = tempNode
        return node     
    
    def recursiveInversion(self, node):
        if node == None:
            return node
        
        elif (node.left  None) and (node.right  None):
            return node
        node = self.switch_node(node)
        node.left = self.recursiveInversion(node.left)
        node.right = self.recursiveInversion(node.right)
        return node

1
2
3
4
5
6
7
8

class Solution:
    def runningSum(self, nums: List[int]) -> List[int]:
        result = []
        accsum = 0
        for num in nums:
            accsum += num
            result += [accsum]
        return result

1
2
3
4
5
6
7
8
9
10

class Solution:
    def maximumWealth(self, accounts: List[List[int]]) -> int:
        max_money = 0
        for customer in accounts:
            customers_money = 0
            for money in customer:
                customers_money += money
            if max_money < customers_money:
                max_money = customers_money
        return max_money

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

class Solution(object):
    def fizzBuzz(self, n):
        """
        :type n: int
        :rtype: List[str]
        """
        result = []
        for j in range(n):
            i = j+1
            if (i%30) and (i%50):
                result += ["FizzBuzz"]
            elif (i%3==0):
                result += ["Fizz"]
            elif (i%5==0):
                result += ["Buzz"]
            else:
                result += [str(i)]
        return result        

1
2
3
4
5
6
7
8

class Solution:
    def numberOfSteps(self, num: int) -> int:
        if (num == 0): return 0
        
        if (not (num % 2)):
            return 1 + self.numberOfSteps(num / 2)
        else:
            return 1 + self.numberOfSteps(num - 1)

1
2
3
4
5
6
7
8
9
10
11

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def middleNode(self, head: Optional[ListNode]) -> Optional[ListNode]:
        arr = [head]
        while arr[-1].next:
            arr.append(arr[-1].next)
        return arr[len(arr) // 2]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

class Solution:
    def canConstruct(self, ransomNote: str, magazine: str) -> bool:
        # Check for obvious fail case.
        if len(ransomNote) > len(magazine): return False

        # In Python, we can use the Counter class. It does all the work that the
        # makeCountsMap(...) function in our pseudocode did!
        magazine_counts = collections.Counter(magazine)
        ransom_note_counts = collections.Counter(ransomNote)
        print(magazine_counts)

        # For each *unique* character in the ransom note:
        for char, count in ransom_note_counts.items():
            # Check that the count of char in the magazine is equal
            # or higher than the count in the ransom note.
            magazine_count = magazine_counts[char]
            if magazine_count < count:
                return False

        # If we got this far, we can successfully build the note.
        return True