From 2e9ca624d234300f9337e03d0af11fde9d23bae8 Mon Sep 17 00:00:00 2001
From: Mayank Padshala <mayankpadshala@gmail.com>
Date: Wed, 15 Oct 2025 01:37:15 +0000
Subject: [PATCH 1/2] Add solution for find-all-numbers-disappeared-in-an-array

---
 find-all-numbers-disappeared.py | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 find-all-numbers-disappeared.py

diff --git a/find-all-numbers-disappeared.py b/find-all-numbers-disappeared.py
new file mode 100644
index 00000000..8beed18a
--- /dev/null
+++ b/find-all-numbers-disappeared.py
@@ -0,0 +1,13 @@
+class Solution:
+    def findDisappearedNumbers(self, nums: List[int]) -> List[int]:
+        res = []
+        for i in range(len(nums)):
+            index = abs(nums[i])
+            if nums[index-1] > 0:
+                nums[index-1] = -1 * nums[index-1]
+        for i in range(len(nums)):
+            if nums[i] > 0:
+                res.append(i+1)
+            else:
+                nums[i] = -1 * nums[i]
+        return res
\ No newline at end of file

From 01b34710d7046a3d88521baa602ad296d827a7bb Mon Sep 17 00:00:00 2001
From: Mayank Padshala <mayankpadshala@gmail.com>
Date: Thu, 16 Oct 2025 03:13:20 +0000
Subject: [PATCH 2/2] Complete Array-2

---
 find_max_min.py | 24 ++++++++++++++++++++++++
 game-of-life.py | 39 +++++++++++++++++++++++++++++++++++++++
 2 files changed, 63 insertions(+)
 create mode 100644 find_max_min.py
 create mode 100644 game-of-life.py

diff --git a/find_max_min.py b/find_max_min.py
new file mode 100644
index 00000000..957904f7
--- /dev/null
+++ b/find_max_min.py
@@ -0,0 +1,24 @@
+# Time Complexity: O(n)
+# Space Complexity: O(1)
+class Solution:
+    def findMaxMin(self, nums: List[int]) -> List[int]:
+        if not nums:
+            return []
+        max_num = nums[0]
+        min_num = nums[0]
+        # Consider a window of size 2
+        # Compare elements in pairs to reduce the number of comparisons
+        # This approach makes about 3n/2 comparisons in the worst case, instead of 2n comparisons
+        # Iterate through the list in steps of 2, comparing pairs, and updating max and min accordingly
+        for i in range(0, len(nums) - 1, 2):
+            if nums[i] > nums[i + 1]:
+                max_num = max(max_num, nums[i])
+                min_num = min(min_num, nums[i + 1])
+            else:
+                max_num = max(max_num, nums[i + 1])
+                min_num = min(min_num, nums[i])
+        # If there's an odd element out, compare it separately
+        if len(nums) % 2 != 0:
+            max_num = max(max_num, nums[-1])
+            min_num = min(min_num, nums[-1])
+        return [max_num, min_num]
\ No newline at end of file
diff --git a/game-of-life.py b/game-of-life.py
new file mode 100644
index 00000000..4e1bda02
--- /dev/null
+++ b/game-of-life.py
@@ -0,0 +1,39 @@
+# Time Complexity: O(m*n)
+# Space Complexity: O(1)
+# This problem can be solved in place by using the following encoding:
+# 0 -> 0 : dead cell remains dead
+# 1 -> 1 : live cell remains live
+# 1 -> 0 : live cell becomes dead (encoded as 2)
+# 0 -> 1 : dead cell becomes live (encoded as 3)
+# Encoding the state changes in this way allows us to keep track of both the current and next states of each cell without using additional space.
+# We iterate through each cell in the board, counting the number of live neighbors.
+# Based on the rules of the Game of Life, we update the cell's state using our encoding. This ensures that we do not interfere with the original state of the cells while determining the next state.
+# After processing all cells, we can update the board by converting 2 to 0 and 3 to 1.
+# This approach ensures that we do not interfere with the original state of the cells while determining the next state.
+class Solution:
+    def gameOfLife(self, board: List[List[int]]) -> None:
+        """
+        Do not return anything, modify board in-place instead.
+        """
+        dir = [[0,1],[1,0],[0,-1],[-1,0],[1,1],[-1,-1],[1,-1],[-1,1]]
+        def countLiveCell(i,j):
+            live = 0
+            for r,c in dir:
+                if 0 <= i+r < len(board) and 0 <= j+c < len(board[0]):
+                    if board[i+r][j+c] == 1 or board[i+r][j+c] == 2:
+                        live += 1
+            return live
+
+        for i in range(len(board)):
+            for j in range(len(board[0])):
+                livecell = countLiveCell(i,j)
+                if board[i][j] == 1:
+                    if livecell < 2: board[i][j] = 2
+                    if livecell > 3: board[i][j] = 2
+                if board[i][j] == 0:
+                    if livecell == 3: board[i][j] = 3
+
+        for i in range(len(board)):
+            for j in range(len(board[0])):
+                if board[i][j] == 2: board[i][j] = 0
+                if board[i][j] == 3: board[i][j] = 1
\ No newline at end of file