minor fixes

Author: minhyeong-joe

Array/DiagonalTraverse2/solution.py

@@ -1,5 +1,6 @@
 from typing import List
 
+
 def findDiagonalOrder(nums: List[List[int]]) -> List[int]:
     # make a index sum pair list [0][0] => 0, [0][1] => 1, [1][0] => 1...
     indexSumPairs = list()
@@ -8,26 +9,25 @@ def findDiagonalOrder(nums: List[List[int]]) -> List[int]:
             indexSumPairs.append((i+j, nums[i][j]))
     # sort by index sum reversed (so it starts with "bottom" of nums array)
     indexSumPairs.sort(key=lambda pair: pair[0], reverse=True)
-    return [v for _,v in reversed(indexSumPairs)]
-            
+    return [v for _, v in reversed(indexSumPairs)]
 
 
 # test driver:
-nums = [[1,2,3],[4,5,6],[7,8,9]]
+nums = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
 print("Input: nums =", nums)
 print("Output:", findDiagonalOrder(nums))
 
 print()
-nums = [[1,2,3,4,5],[6,7],[8],[9,10,11],[12,13,14,15,16]]
+nums = [[1, 2, 3, 4, 5], [6, 7], [8], [9, 10, 11], [12, 13, 14, 15, 16]]
 print("Input: nums =", nums)
 print("Output:", findDiagonalOrder(nums))
 
 print()
-nums = [[1,2,3],[4],[5,6,7],[8],[9,10,11]]
+nums = [[1, 2, 3], [4], [5, 6, 7], [8], [9, 10, 11]]
 print("Input: nums =", nums)
 print("Output:", findDiagonalOrder(nums))
 
 print()
-nums = [[1,2,3,4,5,6]]
+nums = [[1, 2, 3, 4, 5, 6]]
 print("Input: nums =", nums)
-print("Output:", findDiagonalOrder(nums))
+print("Output:", findDiagonalOrder(nums))

Array/FindDuplicateNumber/solution.py

@@ -0,0 +1,26 @@
+from typing import List
+
+
+class Solution:
+    def findDuplicate(self, nums: List[int]) -> int:
+        tortoise = nums[nums[0]]
+        hare = nums[tortoise]
+        print("tortoise: {}, hare: {}".format(tortoise, hare))
+        while tortoise != hare:
+            tortoise = nums[tortoise]
+            hare = nums[nums[hare]]
+            print("tortoise: {}, hare: {}".format(tortoise, hare))
+        tortoise = nums[0]
+        while tortoise != hare:
+            tortoise = nums[tortoise]
+            hare = nums[hare]
+            print("tortoise: {}, hare: {}".format(tortoise, hare))
+        return tortoise
+
+
+# [1,3,4,2,2] equivalent to
+# idx 0 (1) -> idx 1 (3) -> idx 3 (2) -> idx 2 (4) -> idx 4 (2) -> idx 2 (4) ... cycle
+#
+sol = Solution()
+nums = [1, 3, 4, 2, 2]
+print(sol.findDuplicate(nums))

Array/KClosestPointsToOrigin/solution.py

@@ -1,64 +1,13 @@
 from typing import List
 
 
-class MaxHeap():
-    def __init__(self):
-        self.heap = []
-
-    def insert(self, val):
-        self.heap.append(val)
-        self.heapify()
-
-    def getMax(self):
-        return self.heap[0]
-
-    def popMax(self):
-        maxVal = self.heap.pop(0)
-        self.heapify()
-
-    def size(self):
-        return len(self.heap)
-
-    def heapify(self):
-        for i in range(len(self.heap)-1, 0, -1):
-            parentIndex = (i-1) // 2
-            if self.heap[i][0] > self.heap[parentIndex][0]:
-                self.heap[i], self.heap[parentIndex] = self.heap[parentIndex], self.heap[i]
-
-    def __str__(self):
-        return str(self.heap)
-
-    def __iter__(self):
-        return (x for x in self.heap)
-
-
 class Solution:
     def kClosest(self, points: List[List[int]], K: int) -> List[List[int]]:
-        closest = list(list())
-        # find Euclidean distance and put them in key value pair
-        distances = []
-        for point in points:
-            squareSum = point[0]**2 + point[1]**2
-            distances.append((squareSum, point))
-        print(distances)
-        # use max heap of size K to only hold K closest pairs
-        maxHeap = MaxHeap()
-        for distance, point in distances:
-            # print(distance, point)
-            # if maxheap has space, then insert
-            if maxHeap.size() < K:
-                maxHeap.insert((distance, point))
-            else:
-                if distance < maxHeap.getMax()[0]:
-                    maxHeap.popMax()
-                    maxHeap.insert((distance, point))
-        # return all K pairs in max heap
-        print([pair[1] for pair in maxHeap])
-        closest.extend([pair[1] for pair in maxHeap])
-        return closest
+        sortedPoints = sorted(points, key=lambda pair: pair[0]**2+pair[1]**2)
+        return sortedPoints[:K]
 
 
 sol = Solution()
 points = [[3, 3], [5, -1], [-2, 4], [3, 4], [1, 5], [-2, -5], [0, 8]]
-K = 4
+K = 2
 print(sol.kClosest(points, K))

Array/BinaryPrefixDivBy5/Driver.java renamed to BitManipulation/BinaryPrefixDivBy5/Driver.java

@@ -11,7 +11,6 @@ Languages used: Java and Python
 ### [Array](./Array)
 
 - [Add to Array-Form of Integer](Array/AddToArrayFormInteger)
-- [Binary Prefix Divisible by 5](Array/BinaryPrefixDivBy5)
 - [Container With Most Water](Array/ContainerWithMostWater)
 - [Diagonal Traverse II](Array/DiagonalTraverse2)
 - [Divide Arrays In K Consecutive Numbers](Array/DivideArrayInKConsecNums)
@@ -54,6 +53,7 @@ Languages used: Java and Python
 
 ### [Bit Manipulation](./BitManipulation)
 
+- [Binary Prefix Divisible by 5](Array/BinaryPrefixDivBy5)
 - [Single Number II](BitManipulation/SingleNumber2)
 - [Total Hamming Distance](BitManipulation/TotalHammingDistance)