001

01思维/两数之和.py

@@ -0,0 +1,25 @@
+'''
+两数之和
+给定一个整数数组和一个目标值，找出数组中和为目标值的两个数。
+你可以假设每个输入只对应一种答案，且同样的元素不能被重复利用。
+示例:
+给定 nums = [2, 7, 11, 15], target = 9
+因为 nums[0] + nums[1] = 2 + 7 = 9
+所以返回 [0, 1]
+'''
+
+class Solution(object):
+    def twoSum(self,nums,target):
+        """
+        :type nums: List[int]
+        :type target: int
+        :rtype: List[int]
+        """
+        d = {}  # 哈希表
+        for i,num in enumerate(nums):
+            if target - num in d:
+                return [d[target-num],i]
+            d[num] = i
+
+
+print ( Solution().twoSum( [2, 7, 11, 15], 9 ) )           

01思维/加一.py

@@ -0,0 +1,26 @@
+'''
+给定一个由整数组成的非空数组所表示的非负整数，在该数的基础上加一。
+最高位数字存放在数组的首位， 数组中每个元素只存储单个数字。
+你可以假设除了整数 0 之外，这个整数不会以零开头。
+示例 1：输入：[1,2,3] 输出：[1,2,4] 解释：输入数组表示数字 123。
+示例 2：输入：[4,3,2,1] 输出：[4,3,2,2] 解释：输入数组表示数字 4321。
+'''
+
+class Solution(object):
+    def _plusOne(self, digits):
+        """
+        :type digits: List[int]
+        :rtype: List[int]
+        """
+        carry = 1
+        for i in reversed(xrange(0,len(digits))):
+            digit = (digits[i] + carry) % 10
+            carry = 1 if digit < digits[i] else 0
+            digits[i] = digit
+        if carry == 1:
+            return [1] + digits
+        return digits
+
+    # 一句话写法，在int和str之间转换
+    def plusOne(self, digits):
+        return [int(j) for j in str(int(''.join('%s' % i for i in digits))+1)]

01思维/反转整数.py

@@ -0,0 +1,21 @@
+'''
+给出一个有符号正整数，你需要将这个整数中每位上的数字进行反转。
+示例 1: 输入: 123 输出: 321
+示例 2: 输入: 714 输出: 417
+示例 3: 输入: 120 输出: 21
+'''
+
+class Solution(object):
+    def reverse(self,x):
+        """
+        :type x: int
+        :rtype: int
+        """                
+        ans = 0
+        while x:                        
+            ans = ans*10 + x%10  # 不断取x/10的余数
+            x //= 10            
+            if x < 1: break
+        return ans
+    
+print ( Solution().reverse( 123 )  )

01思维/回文数.py

@@ -0,0 +1,32 @@
+'''
+判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。
+示例 1：输入: 121 输出: true
+示例 2：输入: -121 输出: false 解释: 从右向左读为 121- 。
+示例 3：输入: 10 输出: false 解释: 从右向左读为 01 。
+'''
+
+class Solution(object):
+    def _isPalindrome(self, x):  # 列表法，用两个指针，一个从前，一个从后判断是否相同
+        """
+        :type x: int
+        :rtype: bool
+        """
+        str_x = list(str(x))
+        i , j = 0 , len(str_x) - 1  
+        while i < j :
+            if str_x[i] != str_x[j]:
+                return False
+            i += 1  
+            j -=1
+        return True
+
+    def isPalindrome(self, x: int):  # 字符串法
+        if x < 0:
+            return False
+        t=str(x)
+        t =t[::-1]  # 相当于t[-1:-len(t)-1:-1]，从最后一个元素到第一个元素复制一遍，即倒序
+        t=int(t)
+        if x==t:
+            return True
+        else :
+            return False

01思维/插入位置.py

@@ -0,0 +1,26 @@
+'''
+给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。你可以假设数组中无重复元素。
+示例 1：输入：[1,3,5,6], 5 输出：2
+示例 2：输入：[1,3,5,6], 2 输出：1
+示例 3：输入：[1,3,5,6], 7 输出：4
+示例 4：输入：[1,3,5,6], 0 输出：0
+'''
+
+class Solution(object):
+    def searchInsert(self, nums, target):  # 二分法
+        """
+        :type nums: List[int]
+        :type target: int
+        :rtype: int
+        """       
+        lo = 0
+        hi = len(nums)
+        while lo < hi:
+            mid = lo + (hi - lo)/2  # 可以用右移1位代替，mid=(left+right)>>1，位移运算的效率更高
+            if nums[mid] > target:
+                hi = mid
+            elif nums[mid] < target:
+                lo = mid + 1
+            else:
+                return mid
+        return lo

01思维/最后一个单词的长度.py

@@ -0,0 +1,36 @@
+'''
+给定一个仅包含大小写字母和空格 ' ' 的字符串 s，返回其最后一个单词的长度。
+如果字符串从左向右滚动显示，那么最后一个单词就是最后出现的单词。
+如果不存在最后一个单词，请返回 0 。
+说明：一个单词是指仅由字母组成、不包含任何空格的最大子字符串。
+示例：输入："Hello World" 输出：5
+'''
+
+class Solution(object):
+    def _lengthOfLastWord(self, s):  # 调包
+        """
+        :type s: str
+        :rtype: int
+        """
+        if len(s) == 0:
+            return 0
+        s = s.split()  # 通过指定分隔符对字符串进行切片，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等
+        if len(s) > 0:
+            return len(s[-1])
+        return 0
+    # 上述做法一句话写法：
+        return len(s.split()[-1]) if s.split() else 0
+
+    def lengthOfLastWord(self, s):  # 从后往前找
+        """
+        :type s: str
+        :rtype: int
+        """
+        count = 0
+        for i in range(len(s) - 1, -1, -1):
+            if s[i] != " ":
+                while i >= 0 and s[i] != " ":
+                    cnt += 1
+                    i -= 1
+                break
+        return count

01思维/最大子序和.py

@@ -0,0 +1,32 @@
+'''
+给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。
+示例：输入：[-2,1,-3,4,-1,2,1,-5,4] 输出：6 解释：连续子数组 [4,-1,2,1] 的和最大，为 6。
+'''
+
+class Solution(object):
+    def _maxSubArray(self, nums):
+        """
+        :type nums: List[int]
+        :rtype: int
+        """
+        if len(nums) == 0:
+            return 0
+        preSum = maxSum = nums[0]
+        for i in xrange(1,len(nums)):
+            preSum = max(preSum + nums[i],nums[i])
+            maxSum = max(maxSum,preSum)
+        return maxSum
+
+    def maxSubArray(self, nums):
+        if len(nums) == 0:
+            return 0
+        preSum = maxSum = nums[0]
+        for i in xrange(1,len(nums)):
+            preSum = (preSum+nums[i] if preSum>0 else nums[i])  # 类似三目运算符
+            maxSum = max(maxSum,preSum)
+        return maxSum 
+    
+    def maxSubArray(self, nums):
+        for i in range(1, len(nums)):
+            nums[i]= nums[i] + max(nums[i-1], 0)
+        return max(nums)

01思维/最长公共前缀.py

@@ -0,0 +1,33 @@
+'''
+最长公共前缀
+编写一个函数来查找字符串数组中的最长公共前缀。如果不存在公共前缀，返回空字符串 ""。示例 1：输入：["flower","flow","flight"] 输出："fl"
+示例 2：输入: ["dog","racecar","car"] 输出：""
+说明：所有输入只包含小写字母 a-z 。
+'''
+
+class Solution(object):
+    def longestCommonPrefix(self,strs):
+        """
+        :type strs: List[str]
+        :rtype: str
+        """
+        if len(strs) == 0:  # 空字符串
+            return ""
+        i = 0  # 遍历第一个字符
+        j = 0  # 遍历字符串
+        end = 0  # 前缀结尾
+        while j < len(strs) and i < len(strs[j]):
+            if j == 0:  # 以第一个字符作为基准
+                char = strs[j][i] # 取第一个字符的第i位
+            else:
+                if strs[j][i] != char:  # 若其他字符第i位与第一个字符第i位不同，终止
+                    break
+                    
+            if j == len(strs) - 1:  # 若运行到最后一个字符仍没有终止
+                i += 1  # 开始检查第i+1位
+                j = 0  # 回到第一个字符开始新一轮循环
+                end += 1  # 第i位加入前缀
+            else:
+                j += 1  # 吉布森第一个也不是最后一个字符，就到下一个字符
+                
+        return strs[j][:end]

01思维/有效的括号.py

@@ -0,0 +1,27 @@
+'''
+给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串，判断字符串是否有效。
+有效字符串需满足：
+左括号必须用相同类型的右括号闭合。
+左括号必须以正确的顺序闭合。
+注意空字符串可被认为是有效字符串。
+示例 1：输入: "()" 输出: true
+示例 2：输入: "()[]{}" 输出: true
+示例 3：输入: "(]" 输出: false
+示例 4：输入: "([)]" 输出: false
+示例 5：输入: "{[]}" 输出: true
+'''
+
+class Solution(object):
+    def isValid(self,s):
+        """
+        :type s:str
+        :rtype: bool
+        """
+        stack = []
+        d = ["()", "[]", "{}"]
+        for i in xrange(0,len(s)):
+            stack.append(s[i])  # 在列表末尾添加新的对象
+            if len(stack) >=2 and stack[-2]+stack[-1] in d:
+                stack.pop()  # 移除列表中最后一个元素，并且返回该元素的值
+                stack.pop()
+        return len(stack) == 0

01思维/爬楼梯.py

@@ -0,0 +1,21 @@
+'''
+假设你正在爬楼梯。需要 n 阶你才能到达楼顶。每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？
+注意：给定 n 是一个正整数。
+示例 1：输入： 2 输出： 2 解释：1 阶+1 阶 / 2 阶
+示例 2：输入： 3 输出： 3 解释：1 阶+1 阶+1 阶 / 1 阶+2 阶 / 2 阶+1 阶
+'''
+
+class Solution(object):
+    def climbStairs(self, n):
+        """
+        :type n: int
+        :rtype: int
+        """
+        if n <= 1:
+            return 1
+        pre,ppre = 1,1
+        for i in xrange(2,n+1):
+            tmp = pre
+            pre = pre + ppre
+            ppre = tmp
+        return pre