01思维/两数之和.py

@@ -1,25 +0,0 @@
-'''
-两数之和
-给定一个整数数组和一个目标值，找出数组中和为目标值的两个数。
-你可以假设每个输入只对应一种答案，且同样的元素不能被重复利用。
-示例:
-给定 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

@@ -1,26 +0,0 @@
-'''
-给定一个由整数组成的非空数组所表示的非负整数，在该数的基础上加一。
-最高位数字存放在数组的首位， 数组中每个元素只存储单个数字。
-你可以假设除了整数 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

@@ -1,21 +0,0 @@
-'''
-给出一个有符号正整数，你需要将这个整数中每位上的数字进行反转。
-示例 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

@@ -1,32 +0,0 @@
-'''
-判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。
-示例 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

@@ -1,26 +0,0 @@
-'''
-给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。你可以假设数组中无重复元素。
-示例 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

@@ -1,36 +0,0 @@
-'''
-给定一个仅包含大小写字母和空格 ' ' 的字符串 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

@@ -1,32 +0,0 @@
-'''
-给定一个整数数组 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

@@ -1,33 +0,0 @@
-'''
-最长公共前缀
-编写一个函数来查找字符串数组中的最长公共前缀。如果不存在公共前缀，返回空字符串 ""。示例 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

@@ -1,27 +0,0 @@
-'''
-给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串，判断字符串是否有效。
-有效字符串需满足：
-左括号必须用相同类型的右括号闭合。
-左括号必须以正确的顺序闭合。
-注意空字符串可被认为是有效字符串。
-示例 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

@@ -1,21 +0,0 @@
-'''
-假设你正在爬楼梯。需要 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