Merge branch 'master' of https://github.com/siryang/leetcode

Author: yangdi

src2/2Sum/2sum.py

@@ -15,4 +15,18 @@
 class Solution:
     # @return a tuple, (index1, index2)
     def twoSum(self, num, target):
+    	match = dict()
+
+    	for i in range(len(num)):
+    		v = match.get(num[i], None)
+    		if v != None:
+    			return v + 1, i + 1
+
+    		match[target - num[i]] = i
+
+    	return None
+
+if __name__ == '__main__':
+	s = Solution();
+	print s.twoSum([3,2,4], 6)
 

src2/MediaOfTwoSortedArrays/MediaOfTwoSortedArrayst.py

@@ -0,0 +1,80 @@
+'''
+There are two sorted arrays A and B of size m and n respectively. 
+
+Find the median of the two sorted arrays. 
+
+The overall run time complexity should be O(log (m+n)).
+'''
+
+class Solution:
+    # get media of A --> ma
+    # get count of number in B that smaller than ma
+    def getNumBiggerThanValue(self, Array, Value):
+        # lower bounder is better
+        for i in range(len(Array)):
+            if Array[i] > Value:
+                return i + 1
+        return len(Array)
+
+    # return iA, iB
+    def moveFoward(self, A, B, iA, iB):
+        # min of A[iA + 1], B[iB]
+        if iB == len(B):
+            return iA + 1, iB
+        elif iA == len(A):
+            return iB + 1, iA
+        else
+
+    # @return a float
+    def findMedianSortedArrays(self, A, B):
+        lenA = len(A)
+        lenB = len(B)
+        mid = (lenA + lenB) / 2
+        if lenA >= lenB:
+            iA = len(A) / 2
+            iB = self.getNumBiggerThanValue(B, A[iA])
+        else:
+            iB = len(B) / 2
+            iA = self.getNumBiggerThanValue(A, B[iB])
+        A.append(0x8ffffffff)
+        B.append(0x8ffffffff)
+
+        while True:
+            ## step
+            left = iA + iB
+            #print mid, left, iA, iB, ".."
+            if left == mid:
+                return min(A[iA], B[iB])
+            elif left < mid:
+                # step forward
+                if A[iA - 1] > B[iB - 1]:
+                    iB+=1
+                else:
+                    iA+=1
+            elif left > mid:
+                # step backward
+                if A[iA] > B[iB]:
+                    iA-=1
+                else:
+                    iB-=1
+            #print "A:%d, B:%d" %(A[iA], B[iB])
+            
+
+if __name__ == '__main__':
+    slu = Solution()
+    print slu.findMedianSortedArrays([1], [2])
+    print slu.findMedianSortedArrays([1, 12, 15, 26, 38], [2, 13, 17, 30, 45, 50])
+    print slu.findMedianSortedArrays([1, 12, 15, 26, 38], [2, 13, 17, 30, 45])
+    print slu.findMedianSortedArrays([1, 2, 5, 6, 8], [13, 17, 30, 45, 50])
+    print slu.findMedianSortedArrays([1, 2, 5, 6, 8, 9, 10], [13, 17, 30, 45, 50])
+    print slu.findMedianSortedArrays([1, 2, 5, 6, 8, 9], [13, 17, 30, 45, 50])
+    print slu.findMedianSortedArrays([1, 2, 5, 6, 8], [11, 13, 17, 30, 45, 50])
+    print slu.findMedianSortedArrays([1], [2,3,4])
+    ## [1,2,3] --> 2
+    ## [1,2,3,4] --> 3
+    ## [1,2,4,5,5,8] ==> 5
+    ## [1,2,4,5,5,6,8] ==> 5
+        
+
+
+            

src2/MinStack/MinStack.py

@@ -0,0 +1,39 @@
+'''
+Design a stack that supports push, pop, top, and retrieving the minimum element in constant time.
+
+push(x) -- Push element x onto stack.
+pop() -- Removes the element on top of the stack.
+top() -- Get the top element.
+getMin() -- Retrieve the minimum element in the stack.
+'''
+class MinStack:
+    # @param x, an integer
+    # @return an integer
+    def __init__(self):
+        self.m_nums = list()
+        self.m_minValue = 0x8fffffff
+        self.m_minIndex = 0
+
+    def push(self, x):
+        self.m_nums.append(x)
+        if self.m_minValue > x:
+            self.m_minValue, self.m_minIndex = x, len(self.m_nums)
+
+    # @return nothing
+    def pop(self):
+        if self.m_minIndex == len(self.m_nums):
+            self.m_minValue = min(self.m_nums)
+            self.m_minIndex = self.m_nums.index(self.m_minValue)
+
+        self.m_nums.pop()
+
+    # @return an integer
+    def top(self):
+    	if len(self.m_nums) == 0:
+    		return None
+        return self.m_nums[0]
+
+    # @return an integer
+    def getMin(self):
+        return self.m_minValue
+        #return min(self.m_nums)

src2/ReverseInteger/ReverseInteger.py

@@ -0,0 +1,24 @@
+class Solution:
+    # @return an integer
+    def reverse(self, x):
+    	strX = str(x)
+    	#strX = list(strX)
+    	prefix = ''
+    	if strX[0] == '-':
+    		strX = strX[1:]
+    		prefix = '-'
+
+    	strX = list(strX)
+    	strX.reverse()
+    	strX = prefix + ''.join(strX)
+    	x = int(strX)
+    	if x > 2147483647:
+    		return 0
+    	if x < -2147483648:
+    		return 0
+    	return x
+     
+
+if __name__ == '__main__':
+	print Solution().reverse(2147483647)
+	print Solution().reverse(0)