import collections
class Solution:
    def getHint(self, secret, guess):
        """
        :type secret: str
        :type guess: str
        :rtype: str
        """
        n=len(secret)
        cntA = 0
        cnt = 0
        for i in range(n):
            if secret[i] == guess[i]:
                cntA += 1
        d = collections.Counter(secret)
        for s in guess:
            if s in secret:
                d[s] -= 1
        
        for key in d.keys():
            if d[key] >= 0:
                cnt += int(d[key])
        cnt = n -cnt
        return str(cntA)+'A'+str(cnt-cntA)+'B'

import bisect
class MedianFinder(object):

    def __init__(self):
        """
        initialize your data structure here.
        """
        self.res = []

    def addNum(self, num):
        """
        :type num: int
        :rtype: void
        """
        bisect.insort_left(self.res,num)
        
    def findMedian(self):
        """
        :rtype: float
        """
        n = len(self.res)
        if n%2 == 0:
            return (self.res[n//2]+self.res[n//2-1])/2
        else:return self.res[n//2]

# Below is the interface for Iterator, which is already defined for you.
#
# class Iterator(object):
#     def __init__(self, nums):
#         """
#         Initializes an iterator object to the beginning of a list.
#         :type nums: List[int]
#         """
#
#     def hasNext(self):
#         """
#         Returns true if the iteration has more elements.
#         :rtype: bool
#         """
#
#     def next(self):
#         """
#         Returns the next element in the iteration.
#         :rtype: int
#         """

class PeekingIterator(object):
    def __init__(self, iterator):
        """
        Initialize your data structure here.
        :type iterator: Iterator
        """
        self.iter = iterator
        self.pee = self.iter.next() if self.iter.hasNext() else None

    def peek(self):
        """
        Returns the next element in the iteration without advancing the iterator.
        :rtype: int
        """
        return self.pee

    def next(self):
        """
        :rtype: int
        """
        res = self.pee
        self.pee = self.iter.next() if self.iter.hasNext() else None
        return res

    def hasNext(self):
        """
        :rtype: bool
        """
        return self.pee is not None

# Your PeekingIterator object will be instantiated and called as such:
# iter = PeekingIterator(Iterator(nums))
# while iter.hasNext():
#     val = iter.peek()   # Get the next element but not advance the iterator.
#     iter.next()         # Should return the same value as [val].

class Solution(object):
    def findDuplicate(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        tmp = 0
        for i in sorted(nums):
            if tmp == i:
                return i
            tmp = i

class Solution(object):
    def addOperators(self, num, target):
        def dfs(remain, curr_str, curr, prev):
            if not remain and curr == target:
                res.append(curr_str)
                
            for i in range(1, len(remain) + 1):
                if len(curr_str) == 0:   #avoid generate str begin with +-*
                    if not (i > 1 and remain[0] == '0'):   # avoid '0X' case be counted
                        dfs(remain[i:], remain[:i], int(remain[:i]), int(remain[:i]))
                else:
                    if not (i > 1 and remain[0] == '0'):
                        dfs(remain[i:], curr_str + '+' + remain[:i], curr + int(remain[:i]), int(remain[:i]))
                        dfs(remain[i:], curr_str + '-' + remain[:i], curr - int(remain[:i]), -int(remain[:i]))
                        # need take extra care for '*' case, a+b*c = a+b-b+b*c
                        dfs(remain[i:], curr_str + '*' + remain[:i], curr - prev + prev * int(remain[:i]), prev * int(remain[:i]))
            
        res = []
        dfs(num, '', 0, 0)
        return res
print(Solution().addOperators('105',5))

class Solution(object):

    def __init__(self):
        self.lessThan20 = ["", "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine", "Ten",
                       "Eleven", "Twelve", "Thirteen", "Fourteen", "Fifteen", "Sixteen", "Seventeen", "Eighteen", "Nineteen"]
        self.tens = ["", "Ten", "Twenty", "Thirty", "Forty",
                 "Fifty", "Sixty", "Seventy", "Eighty", "Ninety"]
        self.thousands = ["", "Thousand", "Million", "Billion"]


    def numberToWords(self, num):
        if num == 0:
            return "Zero"
        res = ""
        for i in range(len(self.thousands)):
            if num % 1000 != 0:
                res = self.helper(num % 1000) + self.thousands[i] + " " + res
            num /= 1000
        return res.strip()


    def helper(self, num):
        if num == 0:
            return ""
        elif num < 20:
            return self.lessThan20[num] + " "
        elif num < 100:
            return self.tens[num/10] + " " + self.helper(num % 10)
        else:
            return self.lessThan20[num/100] + " Hundred " + self.helper(num % 100)

class Solution(object): # 264. Ugly Number II
	def nthUglyNumber(self, n):
		"""
		:type n: int
		:rtype: int
		"""
		dp = [1 for i in range(n)]
		i2, i3, i5 = 0, 0, 0
		for i in range(1,n):
			n2, n3, n5 = dp[i2]*2, dp[i3]*3, dp[i5]*5
			dp[i] = min(n2, n3, n5)
			if dp[i] == n2: i2 += 1
			if dp[i] == n3: i3 += 1
			if dp[i] == n5: i5 += 1
		# print(dp)
		return dp[-1]

class Solution(object):
    def singleNumber(self, nums):
        """
        :type nums: List[int]
        :rtype: List[int]
        """
        d = {}
        res = []
        for i in nums:
            d[i] = d.get(i,0)+1
        for key in d.keys():
            if d[key] == 1:
                res.append(key)
        return res