class Solution(object):def singleNumber(self, nums):""":type nums: List[int]:rtype: int"""result = 0for each in range(len(nums)):result ^= nums[each]return result

class Solution(object):def reverseString(self, s):lst = []for i in range(len(s)):lst.append(s[-(i + 1)])lst = ''.join(lst)return lst

class Solution(object):def canWinNim(self, n):val = n % 4if val != 0:return Trueelse:return False

class Solution(object):def countBits(self, num):val = [0]while len(val) <= num:val += [i + 1 for i in val]return val[:num + 1]

class Solution(object):def half_adder(self, a, b):s = a ^ bcin = a & breturn s, cindef full_adder(self, a, b, cin):s1, c1 = self.half_adder(a, b)s2, c2 = self.half_adder(cin, s1)c_out = c1 | c2return s2, c_outdef getSum(self, a, b):mask = 1ci = 0sum_total = 0while mask <= 0x080000000:a1 = a & maskb1 = b & mask(s, ci) = self.full_adder(a1, b1, ci)sum_total = sum_total | sci <<= 1mask <<= 1print "s: " + str(s) + "     ci: " + str(ci)maximum = 0x7FFFFFFFmask = 0xFFFFFFFFif sum_total > maximum:sum_total = ~(sum_total ^ mask)return sum_total

class Solution(object):def addDigits(self, num):""":type num: int:rtype: int"""if num == 0:return 0else:return num - 9 * int((num - 1) / 9)

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = Noneclass Solution(object):def maxDepth(self, root):""":type root: TreeNode:rtype: int"""return self.search(root, 0)def search(self, node, i):if node is None:return ielse:i += 1a = self.search(node.left, i)b = self.search(node.right, i)if a > b:return aelse:return b

class Solution(object):def twoSum(self, numbers, target):""":type numbers: List[int]:type target: int:rtype: List[int]"""if not numbers:return []for i in xrange(len(numbers)):if i > 0 and numbers[i-1] == numbers[i]:continueind1 = iind2 = len(numbers) - i -1while ind1 <= ind2:sumv = numbers[ind1] + numbers[ind2]if sumv == target:return [ind1+1, ind2+1]elif sumv > target:ind2 -= 1else:ind1 += 1

class Solution(object):def findTheDifference(self, s, t):""":type s: str:type t: str:rtype: str"""s = list(s)s.sort()t = list(t)t.sort()for i in range(len(s)):if s[i] != t[i]:return t[i]return t[len(t)-1]

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = Noneclass Solution(object):def invertTree(self, root):""":type root: TreeNode:rtype: TreeNode"""self.invert(root)return  rootdef invert(self, node):if node is not None:template = node.leftnode.left = node.rightnode.right = templateself.invert(node.left)self.invert(node.right)

class Solution(object):def singleNumber(self, nums):""":type nums: List[int]:rtype: List[int]"""result = [0, 0]x = 0for each in nums:x ^= each# x = result_1 XOR result_2x &= -xfor each in nums:if each & x == 0:result[0] ^= eachelse:result[1] ^= eachreturn result

class Solution(object):def moveZeroes(self, nums):""":type nums: List[int]:rtype: void Do not return anything, modify nums in-place instead."""real_i = 0for each in xrange(0,len(nums)):nums[real_i] = nums[each]if nums[real_i] != 0:real_i += 1for each in xrange(real_i, len(nums)):nums[each] = 0

from random import randomclass Solution(object):def __init__(self, head):"""@param head The linked list's head.Note that the head is guaranteed to be not null, so it contains at least one node.:type head: ListNode"""self.header = headdef getRandom(self):"""Returns a random node's value.:rtype: int"""head = self.headerindex = 1while head:if random() * index <= 1:value = head.valindex += 1head = head.nextreturn value

class Solution(object):def productExceptSelf(self, nums):""":type nums: List[int]:rtype: List[int]"""output = [1] * len(nums)n = len(nums)template = 1for i in range(1, n):template = template * nums[i - 1]output[i] *= templatetemplate = 1for i in range(n - 2, -1, -1):template = template * nums[i + 1]output[i] *= templatereturn output

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = Noneclass Solution(object):def deleteNode(self, node):""":type node: ListNode:rtype: void Do not return anything, modify node in-place instead."""node.val = node.next.valnode.next = node.next.next

class Solution(object):def canConstruct(self, ransomNote, magazine):""":type ransomNote: str:type magazine: str:rtype: bool"""magazine_dir = {}for each in list(magazine):if magazine_dir.get(each) is not None:magazine_dir[each] += 1else:magazine_dir[each] = 1for each in list(ransomNote):if magazine_dir.get(each) is not None:magazine_dir[each] -= 1if magazine_dir[each] < 0:return Falseelse:return Falsereturn True

class Solution(object):def intersection(self, nums1, nums2):""":type nums1: List[int]:type nums2: List[int]:rtype: List[int]"""set1 = set(nums1)set2 = set(nums2)return list(set1 & set2)

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = Noneclass Solution(object):def isSameTree(self, p, q):""":type p: TreeNode:type q: TreeNode:rtype: bool"""if not p and not q: return Trueif not p or not q: return Falsestack_p = [p]stack_q = [q]while stack_p and stack_q:node_p = stack_p.pop()node_q = stack_q.pop()if node_p.val != node_q.val:return Falseif node_p.left and node_q.left:stack_p.append(node_p.left)stack_q.append(node_q.left)elif not node_p.left and not node_q.left:passelse:return Falseif node_p.right and node_q.right:stack_p.append(node_p.right)stack_q.append(node_q.right)elif not node_p.right and not node_q.right:passelse:return Falsereturn True

class Solution(object):def isSubsequence(self, s, t):"""
        :type s: str:type t: str:rtype: bool"""
        list_s = list(s)list_t = list(t)list_s.sort()list_t.sort()i = 0j = 0while i < len(list_s):if j >= len(list_t):return Falseif list_s[i] == list_t[j]:i += 1j += 1return True

class Solution(object):def topKFrequent(self, nums, k):""":type nums: List[int]:type k: int:rtype: List[int]"""dir_nums = {}for each in nums:if each in dir_nums:dir_nums[each] += 1else:dir_nums[each] = 1return sorted(dir_nums, key=dir_nums.get, reverse=True)[:k]