6.08

Author: princewen

easy/dict保存/242_Valid Anagram.py

@@ -0,0 +1,32 @@
+"""
+
+Given two strings s and t, write a function to determine if t is an anagram of s.
+
+For example,
+s = "anagram", t = "nagaram", return true.
+s = "rat", t = "car", return false.
+
+Note:
+You may assume the string contains only lowercase alphabets.
+
+"""
+
+"""
+my solution
+用两个字典保存字母出现的次数，最后判断两个字典是否相同
+"""
+
+class Solution(object):
+    def isAnagram(self, s, t):
+        """
+        :type s: str
+        :type t: str
+        :rtype: bool
+        """
+        dic1 = {}
+        dic2 = {}
+        for i in s:
+            dic1[i] = dic1.get(i,0)+1
+        for i in t:
+            dic2[i] = dic2.get(i,0)+1
+        return dic1 == dic2

easy/其他/258_Add Digits.py

@@ -0,0 +1,45 @@
+"""
+
+Given a non-negative integer num, repeatedly add all its digits until the result has only one digit.
+
+For example:
+
+Given num = 38, the process is like: 3 + 8 = 11, 1 + 1 = 2. Since 2 has only one digit, return it.
+
+Follow up:
+Could you do it without any loop/recursion in O(1) runtime?
+
+Credits:
+Special thanks to @jianchao.li.fighter for adding this problem and creating all test cases.
+
+"""
+"""
+this method depends on the truth:
+
+N=(a[0] * 1 + a[1] * 10 + ...a[n] * 10 ^n),and a[0]...a[n] are all between [0,9]
+
+we set M = a[0] + a[1] + ..a[n]
+
+and another truth is that:
+
+1 % 9 = 1
+
+10 % 9 = 1
+
+100 % 9 = 1
+
+so N % 9 = a[0] + a[1] + ..a[n]
+
+means N % 9 = M
+
+so N = M (% 9)
+
+as 9 % 9 = 0,so we can make (n - 1) % 9 + 1 to help us solve the problem when n is 9.as N is 9, ( 9 - 1) % 9 + 1 = 9
+"""
+class Solution(object):
+    def addDigits(self, num):
+        """
+        :type num: int
+        :rtype: int
+        """
+        return (num % 9 or 9) if num else 0

easy/搜索相关/278_First Bad Version.py

@@ -0,0 +1,46 @@
+"""
+
+You are a product manager and currently leading a team to develop a new product. Unfortunately, the latest version of your product fails the quality check. Since each version is developed based on the previous version, all the versions after a bad version are also bad.
+
+Suppose you have n versions [1, 2, ..., n] and you want to find out the first bad one, which causes all the following ones to be bad.
+
+You are given an API bool isBadVersion(version) which will return whether version is bad. Implement a function to find the first bad version. You should minimize the number of calls to the API.
+
+"""
+
+"""典型的二分搜索"""
+
+"""值得注意的地方
+Before this problem, I have always use
+
+  mid = (start+end)) / 2;
+To get the middle value, but this can caused OVERFLOW !
+
+when start and end are all about INT_MAX , then (start+end) of course will be overflow !
+
+To avoid the problem we can use
+
+  mid =  start+(end-start)/2;
+
+"""
+
+# The isBadVersion API is already defined for you.
+# @param version, an integer
+# @return a bool
+# def isBadVersion(version):
+
+class Solution(object):
+    def firstBadVersion(self, n):
+        """
+        :type n: int
+        :rtype: int
+        """
+        left = 0
+        right = n-1
+        while left <= right:
+            mid = (left + right) // 2
+            if isBadVersion(mid):
+                right = mid - 1
+            else:
+                left = mid + 1
+        return left

easy/数组/268_Missing Number.py

@@ -0,0 +1,25 @@
+"""
+
+Given an array containing n distinct numbers taken from 0, 1, 2, ..., n, find the one that is missing from the array.
+
+For example,
+Given nums = [0, 1, 3] return 2.
+
+Note:
+Your algorithm should run in linear runtime complexity. Could you implement it using only constant extra space complexity?
+
+"""
+"""
+my solution
+根据等差数列求和公式即可
+"""
+
+
+class Solution(object):
+    def missingNumber(self, nums):
+        """
+        :type nums: List[int]
+        :rtype: int
+        """
+        n = len(nums)
+        return n * (n + 1) / 2 - sum(nums)

easy/树/235_Lowest Common Ancestor of a Binary Search Tree.py

@@ -0,0 +1,38 @@
+"""
+
+Given a binary search tree (BST), find the lowest common ancestor (LCA) of two given nodes in the BST.
+
+According to the definition of LCA on Wikipedia: “The lowest common ancestor is defined between two nodes v and w as the lowest node in T that has both v and w as descendants (where we allow a node to be a descendant of itself).”
+
+        _______6______
+       /              \
+    ___2__          ___8__
+   /      \        /      \
+   0      _4       7       9
+         /  \
+         3   5
+For example, the lowest common ancestor (LCA) of nodes 2 and 8 is 6. Another example is LCA of nodes 2 and 4 is 2, since a node can be a descendant of itself according to the LCA definition.
+"""
+
+# Definition for a binary tree node.
+# class TreeNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+"""考虑二叉搜索树的性质，左子树的值都比根结点小，右子树的值都比根结点大，不断的迭代循环"""
+class Solution(object):
+    def lowestCommonAncestor(self, root, p, q):
+        """
+        :type root: TreeNode
+        :type p: TreeNode
+        :type q: TreeNode
+        :rtype: TreeNode
+        """
+        while root:
+            if root.val < p.val and root.val < q.val:
+                root = root.right
+            elif root.val > p.val and root.val > q.val:
+                root = root.left
+            else:
+                return root

easy/树/257_Binary Tree Paths.py

@@ -0,0 +1,48 @@
+"""
+
+Given a binary tree, return all root-to-leaf paths.
+
+For example, given the following binary tree:
+
+   1
+ /   \
+2     3
+ \
+  5
+All root-to-leaf paths are:
+
+["1->2->5", "1->3"]
+
+"""
+
+"""
+my solution 递归的思想
+"""
+
+
+# Definition for a binary tree node.
+# class TreeNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution(object):
+    def binaryTreePaths(self, root):
+        """
+        :type root: TreeNode
+        :rtype: List[str]
+        """
+        res = []
+        if not root:
+            return res
+        if not root.left and not root.right:
+            return [str(root.val)]
+
+        leftPath = self.binaryTreePaths(root.left)
+        rightPath = self.binaryTreePaths(root.right)
+        for item in leftPath:
+            res.append("->".join([str(root.val), item]))
+        for item in rightPath:
+            res.append("->".join([str(root.val), item]))
+        return res

easy/链表相关/234_Palindrome Linked List.py

@@ -3,7 +3,7 @@
 """
 """
 画图理解更好，使用两个指针，当快的指针跑到头的时候，跑的慢的指针刚好到一半，随后将后一半元素的指向改变，随后循环判断元素是否相等
-相当于先把两个
+相当于先把一个链表分成两个
 """
 
 # Definition for singly-linked list.

easy/链表相关/237_Delete Node in a Linked List.py

@@ -0,0 +1,23 @@
+"""
+
+Write a function to delete a node (except the tail) in a singly linked list, given only access to that node.
+
+Supposed the linked list is 1 -> 2 -> 3 -> 4 and you are given the third node with value 3, the linked list should become 1 -> 2 -> 4 after calling your function.
+
+"""
+"""刚开始还以为这道题错了，后来看了答案豁然开朗，虽然只能知道要删除的节点，没必要直接删除它，用它后一个节点的值替换掉他的值就好了，还是有点神奇的，自己思路太闭塞"""
+
+# Definition for singly-linked list.
+# class ListNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+class Solution(object):
+    def deleteNode(self, node):
+        """
+        :type node: ListNode
+        :rtype: void Do not return anything, modify node in-place instead.
+        """
+        node.val = node.next.val
+        node.next = node.next.next

easy/除余结合/263_Ugly Number.py

@@ -0,0 +1,29 @@
+"""
+
+Write a program to check whether a given number is an ugly number.
+
+Ugly numbers are positive numbers whose prime factors only include 2, 3, 5. For example, 6, 8 are ugly while 14 is not ugly since it includes another prime factor 7.
+
+Note that 1 is typically treated as an ugly number.
+
+"""
+
+"""my solution"""
+
+class Solution(object):
+    def isUgly(self, num):
+        """
+        :type num: int
+        :rtype: bool
+        """
+        if num==0:
+            return False
+        if num==1:
+            return True
+        while num % 2 == 0:
+            num /= 2
+        while num % 3 == 0:
+            num /= 3
+        while num % 5 == 0:
+            num /=5
+        return num == 1