97python

Author: OnlyChristmas

Python/binary-search.py

@@ -0,0 +1,57 @@
+'''
+
+Gven a sorted (in ascending order) integer array nums of n elements and a target value, write a function to search target in nums. If target exists, then return its index, otherwise return -1.
+
+
+Example 1:
+
+Input: nums = [-1,0,3,5,9,12], target = 9
+Output: 4
+Explanation: 9 exists in nums and its index is 4
+
+Example 2:
+
+Input: nums = [-1,0,3,5,9,12], target = 2
+Output: -1
+Explanation: 2 does not exist in nums so return -1
+
+
+Note:
+
+You may assume that all elements in nums are unique.
+n will be in the range [1, 10000].
+The value of each element in nums will be in the range [-9999, 9999].
+
+
+'''
+
+
+class Solution:
+    def search(self, nums, target):
+        """
+        :type nums: List[int]
+        :type target: int
+        :rtype: int
+        """
+        # Approach one
+        # l,r = 0 , len(nums)-1
+        # while l <= r:
+        #     mid = (l + r) // 2
+        #     if nums[mid] == target: return mid
+        #     if l == r : break
+        #     if nums[mid] < target:
+        #         l = mid + 1
+        #     else :
+        #         r = mid
+        # return -1
+
+        # Approach one
+        l,r = 0 , len(nums)-1
+        while l <= r:
+            mid = (l + r) // 2
+            if nums[mid] == target: return mid
+            if nums[mid] < target:
+                l = mid + 1
+            else :
+                r = mid - 1
+        return -1

Python/design-circular-queue.py

@@ -0,0 +1,124 @@
+'''
+
+Design your implementation of the circular queue. The circular queue is a linear data structure in which the operations are performed based on FIFO (First In First Out) principle and the last position is connected back to the first position to make a circle. It is also called "Ring Buffer".
+
+One of the benefits of the circular queue is that we can make use of the spaces in front of the queue. In a normal queue, once the queue becomes full, we cannot insert the next element even if there is a space in front of the queue. But using the circular queue, we can use the space to store new values.
+
+Your implementation should support following operations:
+
+MyCircularQueue(k): Constructor, set the size of the queue to be k.
+Front: Get the front item from the queue. If the queue is empty, return -1.
+Rear: Get the last item from the queue. If the queue is empty, return -1.
+enQueue(value): Insert an element into the circular queue. Return true if the operation is successful.
+deQueue(): Delete an element from the circular queue. Return true if the operation is successful.
+isEmpty(): Checks whether the circular queue is empty or not.
+isFull(): Checks whether the circular queue is full or not.
+
+
+Example:
+
+MyCircularQueue circularQueue = new MyCircularQueue(3); // set the size to be 3
+circularQueue.enQueue(1);  // return true
+circularQueue.enQueue(2);  // return true
+circularQueue.enQueue(3);  // return true
+circularQueue.enQueue(4);  // return false, the queue is full
+circularQueue.Rear();  // return 3
+circularQueue.isFull();  // return true
+circularQueue.deQueue();  // return true
+circularQueue.enQueue(4);  // return true
+circularQueue.Rear();  // return 4
+
+Note:
+
+All values will be in the range of [0, 1000].
+The number of operations will be in the range of [1, 1000].
+Please do not use the built-in Queue library.
+
+'''
+
+
+
+class MyCircularQueue:
+
+    def __init__(self, k):
+        """
+        Initialize your data structure here. Set the size of the queue to be k.
+        :type k: int
+        """
+        self.size = k
+        self.queue = k * [-1]
+        self.head = -1
+        self.rear = -1
+
+
+
+    def enQueue(self, value):
+        """
+        Insert an element into the circular queue. Return true if the operation is successful.
+        :type value: int
+        :rtype: bool
+        """
+        if self.isFull():     # 注意什么时候不能继续入栈
+            return False
+        if self.isEmpty():
+            self.head = 0
+        self.rear = (self.rear + 1) % self.size
+        self.queue[self.rear] = value
+        return True
+
+    def deQueue(self):
+        """
+        Delete an element from the circular queue. Return true if the operation is successful.
+        :rtype: bool
+        """
+        if self.isEmpty():
+            return False
+        if self.head == self.rear:      # 出栈不需要真的删除元素，只需要改变头尾指针
+            self.head = -1              # 首尾指针指到相同元素，且不为-1，此时必然仅有一个元素
+            self.rear = -1
+            return True
+        self.head = (self.head + 1) % self.size
+        return True
+
+
+    def Front(self):
+        """
+        Get the front item from the queue.
+        :rtype: int
+        """
+        return self.queue[self.head] if not self.isEmpty() else -1
+
+
+    def Rear(self):
+        """
+        Get the last item from the queue.
+        :rtype: int
+        """
+        return self.queue[self.rear] if not self.isEmpty() else -1
+
+
+    def isEmpty(self):
+        """
+        Checks whether the circular queue is empty or not.
+        :rtype: bool
+        """
+        return self.head == -1
+
+
+    def isFull(self):
+        """
+        Checks whether the circular queue is full or not.
+        :rtype: bool
+        """
+        return  (self.rear + 1) % self.size == self.head     # 考虑到循环队列，所以去要取整
+
+
+
+# Your MyCircularQueue object will be instantiated and called as such:
+# obj = MyCircularQueue(k)
+# param_1 = obj.enQueue(value)
+# param_2 = obj.deQueue()
+# param_3 = obj.Front()
+# param_4 = obj.Rear()
+# param_5 = obj.isEmpty()
+# param_6 = obj.isFull()

Python/merge-sorted-array.py

@@ -0,0 +1,55 @@
+'''
+
+Given two sorted integer arrays nums1 and nums2, merge nums2 into nums1 as one sorted array.
+
+Note:
+
+The number of elements initialized in nums1 and nums2 are m and n respectively.
+You may assume that nums1 has enough space (size that is greater or equal to m + n) to hold additional elements from nums2.
+Example:
+
+Input:
+nums1 = [1,2,3,0,0,0], m = 3
+nums2 = [2,5,6],       n = 3
+
+Output: [1,2,2,3,5,6]
+
+
+'''
+
+
+class Solution:
+    def merge(self, nums1, m, nums2, n):
+        """
+        :type nums1: List[int]
+        :type m: int
+        :type nums2: List[int]
+        :type n: int
+        :rtype: void Do not return anything, modify nums1 in-place instead.
+        """
+        # Approach one   效率低
+        # a = m - 1
+        # b = n - 1
+        # k = m+n-1
+        # if n > 0:                # List[int] == []
+        #     print(nums1,m,nums2,n)
+        #     if m == 0: nums1[:] = nums2     # nums1  被赋值必须加上 [:]
+        #     else:
+        #         while k >= 0:
+        #             if  nums1[a] >= nums2[b]:
+        #                 nums1[k] = nums1[a]
+        #                 if a == 0 and nums2[b] != -10000:
+        #                     nums1[0] = -10000
+        #                 else:
+        #                     a -= 1
+        #             else:
+        #                 nums1[k] = nums2[b]
+        #                 if b == 0 and nums1[a] != -10000:
+        #                     nums2[0] = -10000
+        #                 else:
+        #                     b -= 1
+        #             k -= 1
+
+        # Approach two
+        nums1[m:] = nums2
+        nums1.sort()

Python/perfect-squares.py

@@ -0,0 +1,82 @@
+'''
+
+Given a positive integer n, find the least number of perfect square numbers (for example, 1, 4, 9, 16, ...) which sum to n.
+
+Example 1:
+
+Input: n = 12
+Output: 3
+Explanation: 12 = 4 + 4 + 4.
+Example 2:
+
+Input: n = 13
+Output: 2
+Explanation: 13 = 4 + 9.
+
+
+'''
+
+
+
+
+
+
+class Solution:
+    def numSquares(self, n):
+        """
+        :type n: int
+        :rtype: int
+        """
+
+        # Approach one 【失败】  贪心算法不适用，大的数不一定会入选
+        # res = [i ** 2  for i in range(1,n//2+1)  if i ** 2 <= n]
+        # print(res)
+        # tmp_ans = count  = 0
+        # ans = []
+        # while len(res) > 1:
+        #     point = -1
+        #     while count != n:
+        #         if res[point] <= n - count:
+        #             count += res[point]
+        #             tmp_ans += 1
+        #         else:
+        #             point -= 1
+        #     ans.append(tmp_ans)
+        #     tmp_ans = count = 0
+        #     del res[-1]
+        # return min(ans) if ans else n
+
+
+        # Approach two 利用队列和BFS，最先搜索到的结果一定是最短的。 队列中存储（位置,步数） ，效率比较低。
+        # q = [[n, 0]]
+        # visited = [False for _ in range(n + 1)]
+        # visited[n] = True
+        # while any(q):
+        #     num, step = q.pop(0)   # 出栈，被pop掉的元素将同时返回给两个变量
+        #     i = 1
+        #     tnum = num - i ** 2
+        #     while tnum >= 0:            # 前进一步
+        #         if tnum == 0: return step + 1   # 最先到达0的一定是步数最少的
+        #         if not visited[tnum]:
+        #             q.append((tnum, step + 1))
+        #             visited[tnum] = True     # 只添加没有遍历过的节点，减少计算量
+        #         i += 1
+        #         tnum = num - i ** 2
+
+
+
+        # Approach three
+        # Lagrange 四平方定理： 任何一个正整数都可以表示成不超过四个整数的平方之和。
+        # 也就是说，这个题目返回的答案只有1、2、3、4这四种可能。 我们可以将输入的数字除以4来大大减少计算量，并不改变答案
+        # 一个数除以8的余数，如果余数为7， 则其必然由四个完全平方数组成
+        # 然后检测是否可以将简化后的数拆分为两个完全平方数，否则一定由三个完全平方数组成。
+        import math
+        while n % 4 == 0: n = n // 4
+        if n % 8 == 7: return 4
+        if int(math.sqrt(n)) ** 2 == n: return 1
+        i = 1
+        while i*i <= n:
+            j = math.sqrt(n - i*i)
+            if int(j) == j: return 2
+            i += 1
+        return 3