From dbd48da286014e9a4d18127f89e71697a3442f36 Mon Sep 17 00:00:00 2001 From: Sanket Kale Date: Mon, 15 Jun 2026 21:49:18 -0500 Subject: [PATCH] Completed Array-1 --- Problem1.py | 54 ++++++++++++++++++++++++++++++++++ Problem2.py | 84 +++++++++++++++++++++++++++++++++++++++++++++++++++++ Problem3.py | 70 ++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 208 insertions(+) create mode 100644 Problem1.py create mode 100644 Problem2.py create mode 100644 Problem3.py diff --git a/Problem1.py b/Problem1.py new file mode 100644 index 00000000..4bba3c41 --- /dev/null +++ b/Problem1.py @@ -0,0 +1,54 @@ +## Problem 1 +# https://leetcode.com/problems/product-of-array-except-self/ +# Given an array nums of n integers where n > 1, return an array output such that output[i] is equal to the product of all the elements of nums except nums[i]. + +# Example: + +# Input: [1,2,3,4] +# Output: [24,12,8,6] +# Note: Please solve it without division and in O(n). + +# Follow up: +# Could you solve it with constant space complexity? (The output array does not count as extra space for the purpose of space complexity analysis.) + +class Solution: + def productExceptSelf(self, nums: List[int]) -> List[int]: + """ + Logic: + To find the product of all elements except the one at the current index, + we can calculate the product of all elements to the left of the index + and multiply it by the product of all elements to the right of the index. + + Time Complexity: O(n) + We iterate through the array of length `n` exactly twice (once forward, + once backward). Both passes take O(n) time, resulting in an overall + linear time complexity. + + Space Complexity: O(1) auxiliary space + The problem explicitly states that the output array `result` does not + count towards the extra space complexity. We only use a few integer + variables (`rp`, `n`), making the auxiliary space complexity O(1). + """ + rp = 1 + n = len(nums) + + # Initialize the result array with 1s + result = [1 for _ in range(n)] + + # First pass (Left to Right): + # Calculate the product of all elements to the LEFT of index i + for i in range(1, n): + rp = rp * nums[i - 1] # Running product of left elements + result[i] = rp # Store the left product in result[i] + + # Reset running product for the right side pass + rp = 1 + + # Second pass (Right to Left): + # Calculate the product of all elements to the RIGHT of index i + # and multiply it directly with the existing left product in result[i] + for i in range(n - 2, -1, -1): + rp = rp * nums[i + 1] # Running product of right elements + result[i] = result[i] * rp # Multiply left product by right product + + return result \ No newline at end of file diff --git a/Problem2.py b/Problem2.py new file mode 100644 index 00000000..d82f4759 --- /dev/null +++ b/Problem2.py @@ -0,0 +1,84 @@ +## Problem 2 +# https://leetcode.com/problems/diagonal-traverse/ +# Given a matrix of M x N elements (M rows, N columns), return all elements of the matrix in diagonal order as shown in the below image. + +# Example: + +# Input: + +# [ + +# [ 1, 2, 3 ], + +# [ 4, 5, 6 ], + +# [ 7, 8, 9 ] + +# ] + +# Output: [1,2,4,7,5,3,6,8,9] + +class Solution: + def findDiagonalOrder(self, mat: List[List[int]]) -> List[int]: + """ + Logic: + We simulate the diagonal traversal by keeping track of our current row (r), + column (c), and the direction we are moving (isGoingUp). + + For each step, we first add the current element to our result array. + Then, we determine the next coordinates based on our current direction: + + 1. Moving UP-RIGHT (isGoingUp = True): + - If we hit the right boundary (c == numCols - 1), we move down to the next row (r += 1) and change direction. + - If we hit the top boundary (r == 0), we move right to the next column (c += 1) and change direction. + - Otherwise, we just keep going up-right (r -= 1, c += 1). + + 2. Moving DOWN-LEFT (isGoingUp = False): + - If we hit the bottom boundary (r == numRows - 1), we move right (c += 1) and change direction. + - If we hit the left boundary (c == 0), we move down (r += 1) and change direction. + - Otherwise, we just keep going down-left (r += 1, c -= 1). + + Time Complexity: O(M * N) + Where M is the number of rows and N is the number of columns in the matrix. + We visit every single element in the matrix exactly once to build the result array. + + Space Complexity: O(1) auxiliary space + We are only using a few variable pointers (`r`, `c`, `isGoingUp`, `numRows`, `numCols`). + The space required for the output array `result` is typically not counted towards + the auxiliary space complexity in these types of problems. + """ + if not mat or not mat[0]: + return [] + + numRows, numCols = len(mat), len(mat[0]) + result = [0] * (numRows * numCols) + + r, c = 0, 0 + isGoingUp = True + + for i in range(numRows * numCols): + result[i] = mat[r][c] + + # Determine the next cell based on the current direction + if isGoingUp: + if c == numCols - 1: # Hit right edge: move down, go left + isGoingUp = False + r += 1 + elif r == 0: # Hit top edge: move right, go left + isGoingUp = False + c += 1 + else: # Normal up-right move + r -= 1 + c += 1 + else: + if r == numRows - 1: # Hit bottom edge: move right, go up + isGoingUp = True + c += 1 + elif c == 0: # Hit left edge: move down, go up + isGoingUp = True + r += 1 + else: # Normal down-left move + r += 1 + c -= 1 + + return result diff --git a/Problem3.py b/Problem3.py new file mode 100644 index 00000000..099eba94 --- /dev/null +++ b/Problem3.py @@ -0,0 +1,70 @@ +# ## Problem 3 +# https://leetcode.com/problems/spiral-matrix/ +# Given a matrix of m x n elements (m rows, n columns), return all elements of the matrix in spiral order. + +# Example 1: + +# Input: + +# [ + +# [ 1, 2, 3 ], + +# [ 4, 5, 6 ], + +# [ 7, 8, 9 ] + +# ] +# Output: [1,2,3,6,9,8,7,4,5] +# Example 2: + +# Input: + +# [ + +# [1, 2, 3, 4], + +# [5, 6, 7, 8], + +# [9,10,11,12] + +# ] +# Output: [1,2,3,4,8,12,11,10,9,5,6,7] + + +# Time Complexity: O(m * n) +# Space Complexity: O(1) +class Solution: + def spiralOrder(self, matrix: List[List[int]]) -> List[int]: + m = len(matrix) + n = len(matrix[0]) + left, top = 0, 0 + right, bottom = n - 1, m - 1 + result = [] + + while left <= right and top <= bottom: + # 1. Traverse from Left to Right along the Top row + for i in range(left, right + 1): + result.append(matrix[top][i]) + top += 1 + + # 2. Traverse from Top to Bottom along the Right column + for i in range(top, bottom + 1): + result.append(matrix[i][right]) + right -= 1 + + # Make sure we are now on a different row + if top <= bottom: + # 3. Traverse from Right to Left along the Bottom row + for i in range(right, left - 1, -1): + result.append(matrix[bottom][i]) + bottom -= 1 + + # Make sure we are now on a different column + if left <= right: + # 4. Traverse from Bottom to Top along the Left column + for i in range(bottom, top - 1, -1): + result.append(matrix[i][left]) + left += 1 + + return result \ No newline at end of file