[Helena] Week 14 solutions

set-matrix-zeroes/yolophg.js

@@ -0,0 +1,64 @@
+// Time Complexity: O(rows * cols)
+// Space Complexity: O(1)
+
+var setZeroes = function (matrix) {
+  // number of rows in the matrix
+  const rows = matrix.length;
+  // number of cols in the matrix
+  const cols = matrix[0].length;
+  // to check if the first row has any zeros
+  let rowZero = false;
+  // to check if the first col has any zeros
+  let colZero = false;
+
+  // check if the first row has any zeros
+  for (let c = 0; c < cols; c++) {
+    if (matrix[0][c] === 0) {
+      rowZero = true;
+      break;
+    }
+  }
+
+  // check if the first col has any zeros
+  for (let r = 0; r < rows; r++) {
+    if (matrix[r][0] === 0) {
+      colZero = true;
+      break;
+    }
+  }
+
+  // use the first row and col to mark zeros
+  for (let r = 1; r < rows; r++) {
+    for (let c = 1; c < cols; c++) {
+      if (matrix[r][c] === 0) {
+        // mark corresponding col in first row
+        matrix[0][c] = 0;
+        // mark corresponding row in first col
+        matrix[r][0] = 0;
+      }
+    }
+  }
+
+  // set matrix elements to zero based on markers in the first row and col
+  for (let r = 1; r < rows; r++) {
+    for (let c = 1; c < cols; c++) {
+      if (matrix[0][c] === 0 || matrix[r][0] === 0) {
+        matrix[r][c] = 0;
+      }
+    }
+  }
+
+  // handle the first row if there was any zero
+  if (rowZero) {
+    for (let c = 0; c < cols; c++) {
+      matrix[0][c] = 0;
+    }
+  }
+
+  // handle the first col if there was any zero
+  if (colZero) {
+    for (let r = 0; r < rows; r++) {
+      matrix[r][0] = 0;
+    }
+  }
+};

spiral-matrix/yolophg.js

@@ -0,0 +1,33 @@
+// Time Complexity: O(m*n) m = number of rows, n = number of cols
+// Space Complexity: O(m*n)
+
+var spiralOrder = function (matrix) {
+  let result = [];
+
+  while (matrix.length > 0) {
+    // add the first row to the result
+    result = result.concat(matrix.shift());
+
+    // add the last element of each remaining row to the result
+    for (let i = 0; i < matrix.length; i++) {
+      if (matrix[i].length > 0) {
+        result.push(matrix[i].pop());
+      }
+    }
+
+    // add the last row in reverse order to the result, if any rows are left
+    if (matrix.length > 0) {
+      result = result.concat(matrix.pop().reverse());
+    }
+
+    // add the first element of each remaining row to the result in reverse order
+    for (let i = matrix.length - 1; i >= 0; i--) {
+      if (matrix[i].length > 0) {
+        result.push(matrix[i].shift());
+      }
+    }
+  }
+
+  // return the result array containing the elements in spiral order
+  return result;
+};

sum-of-two-integers/yolophg.js

@@ -0,0 +1,16 @@
+// Time Complexity: O(log max(a, b))
+// Space Complexity: O(log max(a, b))
+
+var getSum = function (a, b) {
+  // if there is no carry, return a as the result
+  if (b === 0) return a;
+
+  // calculate the sum without carry using XOR
+  let sum = a ^ b;
+
+  // calculate the carry using AND and left shift
+  let carry = (a & b) << 1;
+
+  // recursively call getSum with sum and carry
+  return getSum(sum, carry);
+};