From 17371e62a985bee66504c3e47bd9914b9879b67d Mon Sep 17 00:00:00 2001 From: Arjun Sahasranam Date: Sat, 7 Feb 2026 18:51:44 +0530 Subject: [PATCH] Arrays 1 completed --- DiagonalMatrixTraversal1.java | 94 ++++++++++++++++++++++++++++++++++ MatrixSpiralTraversal.java | 78 ++++++++++++++++++++++++++++ MatrixSpiralTraversal1.java | 81 +++++++++++++++++++++++++++++ ProductOfArrayExceptSelf.java | 40 +++++++++++++++ ProductOfArrayExceptSelf1.java | 44 ++++++++++++++++ 5 files changed, 337 insertions(+) create mode 100644 DiagonalMatrixTraversal1.java create mode 100644 MatrixSpiralTraversal.java create mode 100644 MatrixSpiralTraversal1.java create mode 100644 ProductOfArrayExceptSelf.java create mode 100644 ProductOfArrayExceptSelf1.java diff --git a/DiagonalMatrixTraversal1.java b/DiagonalMatrixTraversal1.java new file mode 100644 index 00000000..3fd71a2e --- /dev/null +++ b/DiagonalMatrixTraversal1.java @@ -0,0 +1,94 @@ +/** + * url: https://leetcode.com/problems/diagonal-traverse/ + * 498. Diagonal Traverse + * Time Complexity: O(m*n) + * Space Complexity: O(m*n) + */ +public class DiagonalMatrixTraversal1 { + + public int[] DiagonalMatrixTraversal(int[][] matrix) { + + int n = matrix[0].length; // column + int m = matrix.length; // row + + if (m == 0 || n == 0) { + return new int[0]; + } + if (m == 1) { + return matrix[0]; + } + if (n == 1) { + int[] result = new int[m]; + for (int k = 0; k < m; k++) { + result[k] = matrix[k][0]; + } + return result; + } + + int[] result = new int[m * n]; + + String direction = "down"; + int i = 0; + int j = 0; + int count = -1; + while (i < m && j < n) { + if ((i == 0 && j == 0) || (i == m - 1 && j == n - 1)) { // first and last + result[++count] = matrix[i][j]; + j++; + } + if (direction.equals("down") && i >= 0 && j < n && i < m && j >= 0) { + result[++count] = matrix[i][j]; + if (j == 0 || i == m - 1) { + if(i < m - 1) { // traverse down if we are not at the last row, else traverse right j + i++; + } else { + j++; + } + direction = "up"; + continue; + } + i++; + j--; + } + + if (direction.equals("up") && i < m && j >= 0 && i >= 0 && j < n) { + result[++count] = matrix[i][j]; + if (i == 0 || j == n - 1) { // traverse right if we are not at the last column, else traverse down i + if (j < n - 1) { + j++; + } else { + i++; + } + + direction = "down"; + continue; + } + i--; + j++; + } + + } + + return result; + } + + public static void main(String[] args) { + int[] result = new DiagonalMatrixTraversal1().DiagonalMatrixTraversal(new int[][]{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}); + for (int r : result) { + System.out.print(r + " "); + } + System.out.println(""); + + result = new DiagonalMatrixTraversal1().DiagonalMatrixTraversal(new int[][]{{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}, {13, 14, 15, 16}}); + for (int r : result) { + System.out.print(r + " "); + } + System.out.println(""); + + result = new DiagonalMatrixTraversal1().DiagonalMatrixTraversal(new int[][]{{1, 2}, {4, 5}, {7, 8}}); + for (int r : result) { + System.out.print(r + " "); + } + System.out.println(""); + } +} diff --git a/MatrixSpiralTraversal.java b/MatrixSpiralTraversal.java new file mode 100644 index 00000000..9b0c54dd --- /dev/null +++ b/MatrixSpiralTraversal.java @@ -0,0 +1,78 @@ +/** + * url: https://leetcode.com/problems/spiral-matrix/ + * 54. Spiral Matrix + * Time Complexity: O(m*n) + * Space Complexity: O(m*n) + */ +public class MatrixSpiralTraversal { + + public int[] spiralTraversal(int[][] matrix) { + int n = matrix[0].length; // column + int m = matrix.length; // row + + int[] result = new int[m * n]; + + int i = 0, j = 0; + int count = -1; + while (result.length - 1 > count) { + // top + while (j < n && matrix[i][j] != 101) { + result[++count] = matrix[i][j]; + matrix[i][j] = 101; + j++; + } + + // right + j--; // reset j to the last valid column + i++; + while (i < m && matrix[i][j] != 101) { + result[++count] = matrix[i][j]; + matrix[i][j] = 101; + i++; + } + // bottom + j--; + i--; // reset i to the last valid row + while (j >= 0 && matrix[i][j] != 101) { + result[++count] = matrix[i][j]; + matrix[i][j] = 101; + j--; + } + + // left + i--; + j++; // reset j to the last valid column + while (i >= 0 && matrix[i][j] != 101) { + result[++count] = matrix[i][j]; + matrix[i][j] = 101; + i--; + } + i++; + j++; + + } + return result; + + } + + public static void main(String[] args) { + int[] result = new MatrixSpiralTraversal().spiralTraversal(new int[][]{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}); + for (int r : result) { + System.out.print(r + " "); + } + System.out.println(""); + + result = new MatrixSpiralTraversal().spiralTraversal(new int[][]{{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}, {13, 14, 15, 16}}); + for (int r : result) { + System.out.print(r + " "); + } + System.out.println(""); + + result = new MatrixSpiralTraversal().spiralTraversal(new int[][]{{1, 2}, {4, 5}, {7, 8}}); + for (int r : result) { + System.out.print(r + " "); + } + System.out.println(""); + } + +} diff --git a/MatrixSpiralTraversal1.java b/MatrixSpiralTraversal1.java new file mode 100644 index 00000000..bedb1c65 --- /dev/null +++ b/MatrixSpiralTraversal1.java @@ -0,0 +1,81 @@ +import java.util.ArrayList; +import java.util.List; +/** + * url: https://leetcode.com/problems/spiral-matrix/ + * 54. Spiral Matrix + * Time Complexity: O(m*n) + * Space Complexity: O(m*n) + * Uses list + */ +public class MatrixSpiralTraversal1 { + + public List spiralTraversal(int[][] matrix) { + int n = matrix[0].length; // column + int m = matrix.length; // row + + List list = new ArrayList<>(); + + int i = 0, j = 0; + while (list.size() < m * n) { + // top + while (j < n && matrix[i][j] != 101) { + list.add(matrix[i][j]); + matrix[i][j] = 101; + j++; + } + + // right + j--; // reset j to the last valid column + i++; + while (i < m && matrix[i][j] != 101) { + list.add(matrix[i][j]); + matrix[i][j] = 101; + i++; + } + // bottom + j--; + i--; // reset i to the last valid row + while (j >= 0 && matrix[i][j] != 101) { + list.add(matrix[i][j]); + matrix[i][j] = 101; + j--; + } + + // left + i--; + j++; // reset j to the last valid column + while (i >= 0 && matrix[i][j] != 101) { + list.add(matrix[i][j]); + matrix[i][j] = 101; + i--; + } + i++; + j++; + + } + + return list; + + } + + public static void main(String[] args) { + List result = new MatrixSpiralTraversal1().spiralTraversal(new int[][]{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}); + for (int r : result) { + System.out.print(r + " "); + } + System.out.println(""); + + result = new MatrixSpiralTraversal1().spiralTraversal(new int[][]{{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}, {13, 14, 15, 16}}); + for (int r : result) { + System.out.print(r + " "); + } + System.out.println(""); + + result = new MatrixSpiralTraversal1().spiralTraversal(new int[][]{{1, 2}, {4, 5}, {7, 8}}); + for (int r : result) { + System.out.print(r + " "); + } + System.out.println(""); + } + +} diff --git a/ProductOfArrayExceptSelf.java b/ProductOfArrayExceptSelf.java new file mode 100644 index 00000000..bea6b35a --- /dev/null +++ b/ProductOfArrayExceptSelf.java @@ -0,0 +1,40 @@ + +/** + * 238. Product of Array Except Self + * Time Complexity: O(n^2) + * Space Complexity: O(n) + */ +public class ProductOfArrayExceptSelf { + + public int[] productExceptSelf(int[] nums) { + int[] result = new int[nums.length]; + + for (int i = 0; i < nums.length; i++) { + int product = 1; + for (int j = 0; j < nums.length; j++) { + // for any i, calculate all j's except i + + if (i == j) { + continue; + } + product = product * nums[j]; + } + result[i] = product; + } + return result; + } + + public static void main(String[] args) { + int[] result = new ProductOfArrayExceptSelf().productExceptSelf(new int[]{1, 2, 3, 4, 5}); + for (int r : result) { + System.out.print(r + " "); + } + System.out.println(""); + result = new ProductOfArrayExceptSelf().productExceptSelf(new int[]{-1, 1, 0, -3, 3}); + for (int r : result) { + System.out.print(r + " "); + } + System.out.println(""); + + } +} diff --git a/ProductOfArrayExceptSelf1.java b/ProductOfArrayExceptSelf1.java new file mode 100644 index 00000000..babbf1ec --- /dev/null +++ b/ProductOfArrayExceptSelf1.java @@ -0,0 +1,44 @@ +/** + * 238. Product of Array Except Self + * Time Complexity: O(n) + * Space Complexity: O(1) if we don't consider the output array, otherwise O(n) + */ +public class ProductOfArrayExceptSelf1 { + + public int[] productExceptSelf(int[] nums) { + int n = nums.length - 1; + int[] result = new int[nums.length]; + // LPS + int product = 1; + for (int i = 0; i <= n; i++) { + if (i != 0) { + product = product * nums[i - 1]; + } + result[i] = product; + } + // RPS + product = 1; + for (int i = n; i >= 0; i--) { + if (i != n) { + product = product * nums[i + 1]; + } + result[i] = result[i] * product; + } + + return result; + } + + public static void main(String[] args) { + int[] result = new ProductOfArrayExceptSelf1().productExceptSelf(new int[]{1, 2, 3, 4, 5}); + for (int r : result) { + System.out.print(r + " "); + } + System.out.println(""); + result = new ProductOfArrayExceptSelf1().productExceptSelf(new int[]{-1, 1, 0, -3, 3}); + for (int r : result) { + System.out.print(r + " "); + } + System.out.println(""); + + } +}