python leetcode 341-350

# 341
class NestedIterator(object):
    def dfs(self, nests):
        for nest in nests:
            if nest.isInteger():
                self.queue.append(nest.getInteger())
            else:
                self.dfs(nest.getList())
                    
    def __init__(self, nestedList):
        self.queue = collections.deque()
        self.dfs(nestedList)

    def next(self):
        return self.queue.popleft()

    def hasNext(self):
        return len(self.queue)

# 342
class Solution:
    def isPowerOfFour(self, n: int) -> bool:
        if n <= 0:
            return False
        res = log10(n) / log10(4)
        return res == int(res)

# 343
class Solution:
    def integerBreak(self, n: int) -> int:
        dp = [1] * (n + 1)
        for i in range(2 , n + 1):
            for j in range(1 , i):
                dp[i] = max(dp[i] , max(dp[j] , j) * max(dp[i - j] , i - j))
        return dp[-1]

# 344
class Solution:
    def reverseString(self, s: List[str]) -> None:
        """
        Do not return anything, modify s in-place instead.
        """
        s[:] = s[::-1]

# 345
class Solution:
    def reverseVowels(self, s: str) -> str:
        dic = set('AEIOUaeiou')
        s_list = list(s)
        l , r = 0 , len(s) - 1
        while l < r:
            while s_list[l] not in dic and l < r:
                l += 1
            while s_list[r] not in dic and l < r:
                r -= 1
            s_list[l] , s_list[r] = s_list[r] , s_list[l]
            l += 1
            r -= 1
        return ''.join(s_list)

# 346
class MovingAverage:
    def __init__(self, size: int):
        self.size = size
        self.queue = []
        
    def next(self, val: int) -> float:
        size, queue = self.size, self.queue
        queue.append(val)
        # calculate the sum of the moving window
        window_sum = sum(queue[-size:])

        return window_sum / min(len(queue), size)

# 347
class Solution:
    def topKFrequent(self, nums: List[int], k: int) -> List[int]:
        res = []
        t = Counter(nums).most_common(k)
        for i in range(k):
            res.append(t[i][0])
        return res

# 349
class Solution:
    def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
        return list(set(nums1) & set(nums2))

# 350
class Solution:
    def intersect(self, nums1: List[int], nums2: List[int]) -> List[int]:
        dict1 = Counter(nums1)
        dict2 = Counter(nums2)
        num = dict1 & dict2
        return list(num.elements())