leetcode

解：暴力解决法

class Solution:
    def twoSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """
        for i in range(len(nums)):
            for j in range(i+1, len(nums)) :
                if (nums[j] == target - nums[i]):
                    return [i, j]

#second 99.55%
#用字典保存已扫描过的数及其下标，扫到一个数x时，字典中查找target - x是否在字典中，若在则找到结果

class Solution:
    def twoSum(self, nums, target):

        d = {}
        length = len(nums)
        for i in range(length):
            if target - nums[i] in d:
                j = d.get(target - nums[i])
return [j,i]
            d[nums[i]] = i

        #80.88%
　　　　　d = {}
        for i in range(len(nums)):
            if target - nums[i] in d:
                return [d[target-nums[i]], i]
            else:
                d[nums[i]] = i

#third
class Solution:
    def twoSum(self, nums, target):

        d = {}
        for index_i, value_i in enumerate(nums):
            value_j = target - value_i
            if value_j not in d:
                d[value_i] = index_i
            else:
                index_j = d[value_j]
                return [index_j, index_i]

1）递归法
class Solution:
    def myPow(self, x, n):
        if n < 0:
            return self.myPow(1/x,-n)
        if n == 0:
            return 1
        if n == 2:
            return x*x
        return self.myPow(self.myPow(x,n/2),2) if not n%2 else x * self.myPow(self.myPow(x,n//2),2)
#将幂不断除2，除到奇数时减1继续除，使得程序复杂度控制在O(log n)里。
--------------------- 
2）按位运算
class Solution:
    def myPow(self, x, n):
        if n == 0:
            return 1
        elif n < 0:
            x = 1/x
            n = -n
        ans = 1.0
        while n > 0:
            if n&1 :
                ans *= x
            x *= x
            n >>= 1
        return ans
#为了消除递归使用了位运算及循环。虽然时间复杂度没变，但是大量冗余的代码并不比递归函数要快

class Solution:
    def mySqrt(self, x):
        """
        :type x: int
        :rtype: int
        """
        if x < 2:
            return x
        left = 0 
        right = x  
        
        while left <= right:
            mid = (left + right) // 2
            if x > mid * mid:
                left = mid + 1
                ans = mid
            elif x < mid*mid:
                right = mid -1
            else:
                return mid
        return ans
                

class Solution:
    def findMedianSortedArrays(self, nums1, nums2):
        """
        :type nums1: List[int]
        :type nums2: List[int]
        :rtype: float
        """
        nums  = nums1 + nums2
        nums.sort()
        l = len(nums)
        if  l % 2 :
            return nums[l//2]
        else:
            return (nums[l//2-1] + nums[l//2]) / 2