1089_Duplicate_Zeros

Author: Partho Biswas

README.md

@@ -167,6 +167,7 @@ I have solved quite a number of problems from several topics. See the below tabl
 |56| **[849. Maximize Distance to Closest Person](https://tinyurl.com/v44bs88)** | [Python](https://tinyurl.com/wu6rdaw/849_Maximize_Distance_to_Closest_Person.py), [Swift](https://tinyurl.com/wuja3c4/849_Maximize_Distance_to_Closest_Person.swift) | [Art 1](https://tinyurl.com/qsenvnd) | Easy | Not so easy and intuitive. Can be solve is a variety of way. I have used Binary search(A bit over engineered solution). Can be simplifies |
 |57| **[283. Move Zeroes](https://tinyurl.com/y5kxjuvc)** | [Python](https://tinyurl.com/wu6rdaw/283_Move_Zeroes.py), [Swift](https://tinyurl.com/wuja3c4/283_Move_Zeroes.swift) | --- | Easy | Not so easy and intuitive. Uses fast and slow pointer |
 |58| **[163. Missing Ranges](https://tinyurl.com/s297jm7)** | [Python](https://tinyurl.com/wu6rdaw/163_Missing_Ranges.py), [Swift](https://tinyurl.com/wuja3c4/163_Missing_Ranges.swift) | --- | Medium | Man, it's a very trick problem |
+|59| **[1089. Duplicate Zeros](https://tinyurl.com/vdlwjwa)** | [Python](https://tinyurl.com/wu6rdaw/1089_Duplicate_Zeros.py), [Swift](https://tinyurl.com/wuja3c4/1089_Duplicate_Zeros.swift) | [Art 1](https://tinyurl.com/y3b2ynd4) | Easy | Not so easy and intuitive. Check again |
 
 
 </p>
@@ -575,7 +576,7 @@ BFS, DFS, Dijkstra, Floyd–Warshall, Bellman-Ford, Kruskal, Prim's, Minimum Spa
 | --- | --- | --- | --- | --- | --- |
 |01| **[1055. Shortest Way to Form String](https://leetcode.com/problems/shortest-way-to-form-string/)**| [Python](https://tinyurl.com/wu6rdaw/1055_Shortest_Way_to_Form_String.py)| [Art 1](https://tinyurl.com/t6xap4c), [Art 2](https://leetcode.com/problems/shortest-way-to-form-string/discuss/330938/Accept-is-not-enough-to-get-a-hire.-Interviewee-4-follow-up) | Medium | 📌 **[Check BS approach again](https://tinyurl.com/t6xap4c)** |
 |02| [1057. Campus Bikes](https://leetcode.com/problems/campus-bikes/)| [Python](https://tinyurl.com/wu6rdaw/1057_Campus_Bikes.py)| [Video 01](https://www.youtube.com/watch?v=tG7GFge4-fQ), [Article 01](https://leetcode.com/problems/campus-bikes/discuss/371604/Python-Solution-Using-Dictionary-With-Explanation)| Medium | 📌 Solve [1066. Campus Bikes II](https://leetcode.com/problems/campus-bikes-ii/) using [DP](https://leetcode.com/problems/campus-bikes-ii/discuss/303471/Python-DP-vs-Backtracking-with-comments), [DFS](https://leetcode.com/problems/campus-bikes-ii/discuss/303383/Python-DFS-with-memorization) and [Priority Queue](https://leetcode.com/problems/campus-bikes-ii/discuss/303422/Python-Priority-Queue) |
-|03| [1007. Minimum Domino Rotations For Equal Row](https://leetcode.com/problems/minimum-domino-rotations-for-equal-row/)| [Python](https://tinyurl.com/wu6rdaw/Minimum_Domino_Rotations_For_Equal_Row.py)| [Official](https://leetcode.com/problems/minimum-domino-rotations-for-equal-row/solution/), [Article 01](https://leetcode.com/problems/minimum-domino-rotations-for-equal-row/discuss/252242/JavaC%2B%2BPython-Different-Ideas)| Medium | 📌 Hard to spot if it is a Greedy |
+|03| **[1007. Minimum Domino Rotations For Equal Row](https://tinyurl.com/y6qgt5fk)** | [Python](https://tinyurl.com/wu6rdaw/Minimum_Domino_Rotations_For_Equal_Row.py)| [Vid 1](https://tinyurl.com/uobop48), [Vid 2](https://tinyurl.com/qkqlcmv),[Art 1](https://tinyurl.com/ufvb3kg),[Art 2](https://tinyurl.com/u85uegn),[Art 3](https://tinyurl.com/yxq7q9v6) | Medium | 📌 Hard to spot if it is a Greedy. Very Important |
 |04| [406. Queue Reconstruction by Height](https://leetcode.com/problems/queue-reconstruction-by-height/)| [Python](https://tinyurl.com/wu6rdaw/406_Queue_Reconstruction_by_Height.py)| [Article 1](https://leetcode.com/problems/queue-reconstruction-by-height/discuss/89345/Easy-concept-with-PythonC%2B%2BJava-Solution), [Article 2](https://leetcode.com/problems/queue-reconstruction-by-height/discuss/89359/Explanation-of-the-neat-Sort%2BInsert-solution) | Medium | 📌 Fundamentals |
 |05| [621. Task Scheduler](https://leetcode.com/problems/task-scheduler/)| [Python](https://tinyurl.com/wu6rdaw/621_Task_Scheduler.py)| [Ex 1](https://leetcode.com/problems/task-scheduler/discuss/190390/Can-anyone-explain-to-me-what-the-problem-is-asking), [Ex 2](https://leetcode.com/problems/task-scheduler/discuss/130786/Python-solution-with-detailed-explanation), [Vid 1](https://www.youtube.com/watch?v=hVhOeaONg1Y), [Vid 2](https://www.youtube.com/watch?v=zPtI8q9gvX8), [Vid 3](https://www.youtube.com/watch?v=TV9VlHUR-Is), [Vid 4](https://www.youtube.com/watch?v=cr6Ip0J9izc&t=22s) | Medium | 📌 Extremely tricky. Classic problem |
 |06| [392. Is Subsequence](https://leetcode.com/problems/is-subsequence/)| [Python](https://tinyurl.com/wu6rdaw/392_Is_Subsequence.py)| [Ex 1](https://leetcode.com/problems/is-subsequence/discuss/87264/Easy-to-understand-binary-search-solution), [Ex 3](https://leetcode.com/problems/is-subsequence/discuss/87302/Binary-search-solution-for-follow-up-with-detailed-comments/144323) | Easy | 📌  |

algoexpert.io/python/Bubble_Sort.py

@@ -1,21 +1,19 @@
 
 # Best: O(n) time | O(1) space
-# Avarage: O(n^2) time | O(1) space
+# Average: O(n^2) time | O(1) space
 # Worst: O(n^2) time | O(1) space
-def bubblesort(input_array):
-    is_sorted = False
-    counter = 0
-    while not is_sorted:
-        is_sorted = True
-        for i in range(len(input_array) - 1 - counter):
-            if input_array[i] > input_array[i + 1]:
-                swap(i, i + 1, input_array)
-                is_sorted = False
-            counter += 1
-    return input_array
-
+def bubbleSort(array):
+ 	isSorted = False
+ 	counter = 0
+ 	while not isSorted:
+ 		isSorted = True
+ 		for i in range(len(array) - 1 - counter):
+ 			if array[i] > array[i + 1]:
+ 				swap(i, i + 1, array)
+ 				isSorted = False
+ 		counter += 1
+ 	return array
 
 def swap(i, j, array):
-    array[i], array[j] = array[j], array[i]
-
+ 	array[i], array[j] = array[j], array[i]
 

algoexpert.io/python/Find_Loop.py

@@ -1,13 +1,19 @@
 
 # O(n) time | O(1) space
+class LinkedList:
+    def __init__(self, value):
+        self.value = value
+        self.next = None
+
 def findLoop(head):
-    first = head.next
-    second = head.next.next
-    while first != second:
-        first = first.next
-        second = second.next.next
-    first = head
-    while first != second:
-        first = first.next
-        second = second.next
-    return first
+	if not head and not head.next:
+		return None
+    slowPtr, fastPtr = head.next, head.next.next
+	while slowPtr != fastPtr:
+		slowPtr = slowPtr.next
+		fastPtr = fastPtr.next.next
+	fastPtr = head
+	while fastPtr != slowPtr:
+		slowPtr = slowPtr.next
+		fastPtr = fastPtr.next
+	return fastPtr

algoexpert.io/python/Insertion_Sort.py

@@ -2,17 +2,19 @@
 
 
 # Best: O(n) time | O(1) space
-# Avarage: O(n^2) time | O(1) space
+# Average: O(n^2) time | O(1) space
 # Worst: O(n^2) time | O(1) space
-def insersion_sort(array):
-    for i in range(1, len(array)):
-        j = i
-        while j > 0 and array[j] < array[j - 1]:
-            array[j], array[j - 1] = array[j - 1], array[j]
-            j -= 1
-    return array
+def insertionSort(array):
+ 	for i in range(1, len(array)):
+ 		j = i
+ 		while j > 0 and array[j] < array[j - 1]:
+ 			swap(j, j - 1, array)
+ 			j -= 1
+ 	return array
+def swap(i, j, array):
+ 	array[i], array[j] = array[j], array[i]
 
 
 input_array = [8, 5, 2, 9, 5, 6, 3]
-sorted_array = insersion_sort(input_array)
+sorted_array = insertionSort(input_array)
 print("Sorted Array: ", sorted_array)

algoexpert.io/python/Max_Sum_Increasing_Subsequence.py

@@ -1,27 +1,23 @@
-
-
-
-
 def maxSumIncreasingSubsequence(array):
-    sequences = [None for x in array]
-    sums = [num for num in array]
-    maxSumIdx = 0
-    for i in range(len(array)):
-        currentNum = array[i]
-        for j in range(0, i):
-            otherNum = array[j]
-            if otherNum < currentNum and sums[j] + currentNum >= sums[i]:
-                sums[i] = sums[j] + currentNum
-                sequences[i] = j
-        if sums[i] >= sums[maxSumIdx]:
-            maxSumIdx = i
-    return [sums[maxSumIdx], buildSequence(array, sequences, maxSumIdx)]
-
+    sequeces = [None for _ in array]
+	sums = [num for num in array]
+	maxSumIdx = 0
+	for i in range(len(array)):
+		currentum = array[i]
+		for j in range(0, i):
+			otherum = array[j]
+			if otherum < currentum and sums[j] + currentum >= sums[i]:
+				sums[i] = sums[j] + currentum
+				sequeces[i] = j
+		if sums[maxSumIdx] <= sums[i]:
+			maxSumIdx = i
+	increasigSequence = buildSequece(array, sequeces, maxSumIdx)
+	return [sums[maxSumIdx], increasigSequence]
 
-def buildSequence(array, sequences, currentIdx):
-    sequence = []
-    while currentIdx is not None:
-        sequence.append(array[currentIdx])
-        currentIdx = sequences[currentIdx]
-    return list(reversed(sequence))
+def buildSequece(array, sequeces, curIdx):
+	sequen = []
+	while curIdx is not None:
+		sequen.append(array[curIdx])
+		curIdx = sequeces[curIdx]
+	return list(reversed(sequen))
 

leetcode.com/python/1007_Minimum_Domino_Rotations_For_Equal_Row.py

@@ -0,0 +1,65 @@
+# Source: https://tinyurl.com/v3zqer7
+# Approach 1
+class Solution(object):
+    def minDominoRotations(self, A, B):
+        """
+        :type A: List[int]
+        :type B: List[int]
+        :rtype: int
+        """
+        result = float("inf")
+        for domino in range(1, 7):  # Since each domino can have only 1 to 6 values. So check all values if we can make it
+            isPossible = True
+            topRorationCount, bottomRotationCount = 0, 0
+            for a, b in zip(A, B):
+                if domino != a and domino != b: #
+                    isPossible = False
+                    break
+                if domino == a and domino != b:
+                    bottomRotationCount += 1
+                elif domino != a and domino == b:
+                    topRorationCount += 1
+            if isPossible:
+                result = min(result, min(topRorationCount, bottomRotationCount))
+        return -1 if result == float("inf") else result
+
+
+
+# Source: https://tinyurl.com/v3zqer7
+# Approach 2
+class Solution(object):
+    def minDominoRotations(self, A, B):
+        """
+        :type A: List[int]
+        :type B: List[int]
+        :rtype: int
+        """
+        rotations = self.checkRotationFor(A, B, A[0])
+        # If one could make all elements in A or B equal to A[0]
+        if rotations != -1 or A[0] == B[0]:
+            return rotations
+        # If one could make all elements in A or B equal to B[0]
+        else:
+            return self.checkRotationFor(A, B, B[0])
+
+    def checkRotationFor(self, A, B, num):
+        """
+        Return minimum number of swaps,
+        if one could make all elements in A or B equal to 'num'.
+        Else return -1
+        """
+        # How many rotations should be done
+        # to have all elements in A equal to 'num'
+        # and to have all elements in B equal to 'num'
+        length = len(A)
+        rotations_A, rotations_B = 0, 0
+        for i in range(length):
+            if A[i] != num and B[i] != num:
+                return -1
+            elif A[i] != num:
+                rotations_A += 1
+            elif B[i] != num:
+                rotations_B += 1
+        return min(rotations_A, rotations_B)
+
+

leetcode.com/python/1089_Duplicate_Zeros.py

@@ -0,0 +1,53 @@
+# My initial solution. 14 / 30 test cases passed.
+class Solution(object):
+    def duplicateZeros(self, arr):
+        """
+        :type arr: List[int]
+        :rtype: None Do not return anything, modify arr in-place instead.
+        """
+        zeros = []
+        for i in range(len(arr)):
+            if arr[i] == 0:
+                zeros.append(i)
+        for i in zeros:
+            if i + 2 < len(arr):
+                prevNum = arr[i + 1]
+                arr[i + 1] = 0
+                for j in range(i + 2, len(arr)):
+                    currrentNum = arr[j]
+                    arr[j] = prevNum
+                    prevNum = currrentNum
+
+# Vary inefficient solution. Does't respect the constraints.
+class Solution:
+	def duplicateZeros(self, arr):
+		i = 0
+		n = len(arr)
+		while(i<n):
+			if arr[i] == 0:
+				arr.pop()
+				arr.insert(i,0)
+				i+=1
+			i+=1
+
+# Optimised and good solution
+# Source: https://tinyurl.com/qnxv356
+class Solution:
+    def duplicateZeros(self, arr):
+        """
+        Do not return anything, modify arr in-place instead.
+        """
+        shift = 0
+        l = len(arr)
+        for i in range(l):
+            if arr[i] == 0:
+                shift += 1
+        for i in range(l-1, -1, -1):
+            # put the shifted number in the right spot
+            if i + shift < l:
+                arr[i+shift] = arr[i]
+            # if we meet a 0, we need to duplicate 0
+            if arr[i] == 0:
+                shift -= 1
+                if i + shift < l:
+                    arr[i+shift] = 0