0620

Author: princewen

sort_by_leetcode/array/easy/217. Contains Duplicate.py

@@ -2,8 +2,28 @@
 
 Given an array of integers, find if the array contains any duplicates. Your function should return true if any value appears at least twice in the array, and it should return false if every element is distinct.
 
+Subscribe to see which companies asked this question.
+
 """
-"""使用set不能有重复值的特性，判断前后长度是否相同"""
+"""利用hash table，别忘了判断空数组的情况.其实更麻烦"""
+
+class Solution(object):
+    def containsDuplicate(self, nums):
+        """
+        :type nums: List[int]
+        :rtype: bool
+        """
+        if not nums:
+            return False
+        dic = dict()
+        for num in nums:
+            if num in dic:
+                return True
+            dic[num] = 1
+        return False
+
+"""直接利用set的性质反而更简单"""
+
 class Solution(object):
     def containsDuplicate(self, nums):
         """

sort_by_leetcode/hashtable/__init__.py

@@ -0,0 +1,28 @@
+"""
+
+Given an array of integers, return indices of the two numbers such that they add up to a specific target.
+
+You may assume that each input would have exactly one solution, and you may not use the same element twice.
+
+Example:
+Given nums = [2, 7, 11, 15], target = 9,
+
+Because nums[0] + nums[1] = 2 + 7 = 9,
+return [0, 1].
+
+"""
+
+class Solution(object):
+    def twoSum(self, nums, target):
+        """
+        :type nums: List[int]
+        :type target: int
+        :rtype: List[int]
+        """
+        dic = dict()
+        for index,value in enumerate(nums):
+            sub = target - value
+            if sub in dic:
+                return [dic[sub],index]
+            else:
+                dic[value] = index

sort_by_leetcode/hashtable/easy/1. Two Sum.py

@@ -0,0 +1,22 @@
+"""
+
+Given an array of integers, every element appears twice except for one. Find that single one.
+
+Note:
+Your algorithm should have a linear runtime complexity. Could you implement it without using extra memory?
+
+"""
+"""这道题虽然放在了hashtable里，但其实用二进制的算法更容易求解
+两个相同数的二进制异或为0，所以遍历一边数组，出现两次的异或值变为0，那么剩下的数就是出现一次的数
+"""
+
+class Solution(object):
+    def singleNumber(self, nums):
+        """
+        :type nums: List[int]
+        :rtype: int
+        """
+        res = 0
+        for i in nums:
+            res = res ^ i
+        return res

sort_by_leetcode/hashtable/easy/136. Single Number.py

@@ -0,0 +1,45 @@
+"""
+
+Write an algorithm to determine if a number is "happy".
+
+A happy number is a number defined by the following process: Starting with any positive integer, replace the number by the sum of the squares of its digits, and repeat the process until the number equals 1 (where it will stay), or it loops endlessly in a cycle which does not include 1. Those numbers for which this process ends in 1 are happy numbers.
+
+Example: 19 is a happy number
+
+12 + 92 = 82
+82 + 22 = 68
+62 + 82 = 100
+12 + 02 + 02 = 1
+Credits:
+Special thanks to @mithmatt and @ts for adding this problem and creating all test cases.
+
+"""
+
+"""解法1，用列表保存出现过的数，当出现重复的数字的时候，说明出现了循环，循环有两种情况，一种不是hayyp数，循环的数必不是1，如果是happy数，那么会出现1的不断循环"""
+class Solution(object):
+    def isHappy(self, n):
+        """
+        :type n: int
+        :rtype: bool
+        """
+        c = set()
+        while not n in c:
+            c.add(n)
+            n = sum([int(x) ** 2 for x in str(n)])
+        return n==1
+
+"""解法2，使用追赶法，快的指针每次前进两步，慢的指针每次只前进一步，当快的指针追上慢的指针即二者数字相同时，同样说明出现了
+循环，情况同上"""
+class Solution(object):
+    def isHappy(self, n):
+        """
+        :type n: int
+        :rtype: bool
+        """
+        slow = n
+        quick = sum([int(x) ** 2 for x in str(n)])
+        while quick != slow:
+            quick = sum([int(x) ** 2 for x in str(quick)])
+            quick = sum([int(x) ** 2 for x in str(quick)])
+            slow = sum([int(x) ** 2 for x in str(slow)])
+        return slow == 1

sort_by_leetcode/hashtable/easy/202. Happy Number.py

@@ -0,0 +1,24 @@
+"""
+
+Description:
+
+Count the number of prime numbers less than a non-negative number, n.
+
+"""
+
+"""统计比n小的质数有多少，首先设置一个数组，全部质为true，然后遍历2-sqrt（n）的数，把他们的倍数所在的数组位置
+置为True这里为了避免重复，从i*i的位置开始，而不是从i*2的位置开始，因为i*2，i*3，i*n-1其实已经置为false了
+"""
+class Solution(object):
+    def countPrimes(self, n):
+        """
+        :type n: int
+        :rtype: int
+        """
+        if n < 3:
+            return 0
+        res = [True] * n
+        res[0] = res[1] = False
+        for i in range(2,int(math.sqrt(n)) + 1):
+            res[i*i:n:i] = [False] * len(res[i*i:n:i])
+        return sum(res)

sort_by_leetcode/hashtable/easy/204. Count Primes.py

@@ -0,0 +1,63 @@
+"""
+
+Given two strings s and t, determine if they are isomorphic.
+
+Two strings are isomorphic if the characters in s can be replaced to get t.
+
+All occurrences of a character must be replaced with another character while preserving the order of characters. No two characters may map to the same character but a character may map to itself.
+
+For example,
+Given "egg", "add", return true.
+
+Given "foo", "bar", return false.
+
+Given "paper", "title", return true.
+
+"""
+
+"""一开始我的解法是这样的，但是这是不对的，如下面的情况s='ab',t='aa' 就会出现错误"""
+class Solution(object):
+    def isIsomorphic(self, s, t):
+        """
+        :type s: str
+        :type t: str
+        :rtype: bool
+        """
+        if len(s) != len(t):
+            return False
+        dic = dict()
+        for i in range(len(s)):
+            if s[i] in dic and dic[s[i]] != t[i]:
+                return False
+            else:
+                dic[s[i]] = t[i]
+        return True
+"""所以用两个dict分别对应保存两个字符串对应位置的对方字符，只要其中一个不满足条件，则返回错误"""
+class Solution(object):
+    def isIsomorphic(self, s, t):
+        """
+        :type s: str
+        :type t: str
+        :rtype: bool
+        """
+        if len(s) != len(t):
+            return False
+        dic1 = dict()
+        dic2 = dict()
+        for i in range(len(s)):
+            if (s[i] in dic1 and dic1[s[i]] != t[i]) or (t[i] in dic2 and dic2[t[i]] != s[i]):
+                return False
+            else:
+                dic1[s[i]] = t[i]
+                dic2[t[i]] = s[i]
+        return True
+
+"""其实，还有更简单的解法,使用zip将两个数组对应位置元素相连，再利用set不能有重复元素的特性，判断三者的长度是否相同即可"""
+class Solution(object):
+    def isIsomorphic(self, s, t):
+        """
+        :type s: str
+        :type t: str
+        :rtype: bool
+        """
+        return len(set(zip(s,t))) == len(set(s)) == len(set(t))

sort_by_leetcode/hashtable/easy/205. Isomorphic Strings.py

@@ -0,0 +1,33 @@
+"""
+
+Given an array of integers, find if the array contains any duplicates. Your function should return true if any value appears at least twice in the array, and it should return false if every element is distinct.
+
+Subscribe to see which companies asked this question.
+
+"""
+"""利用hash table，别忘了判断空数组的情况.其实更麻烦"""
+
+class Solution(object):
+    def containsDuplicate(self, nums):
+        """
+        :type nums: List[int]
+        :rtype: bool
+        """
+        if not nums:
+            return False
+        dic = dict()
+        for num in nums:
+            if num in dic:
+                return True
+            dic[num] = 1
+        return False
+
+"""直接利用set的性质反而更简单"""
+
+class Solution(object):
+    def containsDuplicate(self, nums):
+        """
+        :type nums: List[int]
+        :rtype: bool
+        """
+        return len(nums) != len(set(nums))

sort_by_leetcode/hashtable/easy/217. Contains Duplicate.py

@@ -0,0 +1,19 @@
+"""
+
+Given an array of integers and an integer k, find out whether there are two distinct indices i and j in the array such that nums[i] = nums[j] and the absolute difference between i and j is at most k.
+
+"""
+"""仍然用dict保存数组元素出现的位置，两种情况下更新"""
+class Solution(object):
+    def containsNearbyDuplicate(self, nums, k):
+        """
+        :type nums: List[int]
+        :type k: int
+        :rtype: bool
+        """
+        dic = dict()
+        for index,value in enumerate(nums):
+            if value in dic and index - dic[value] <= k:
+                return True
+            dic[value] = index
+        return False

sort_by_leetcode/hashtable/easy/219. Contains Duplicate II.py

@@ -0,0 +1,26 @@
+"""
+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.
+
+"""
+"""用两个字典保存字符出现的情况，判断两个字典是否相同即可"""
+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