Feedback

DSA-Assignments/week 1/Arrays 1/countElements.js

@@ -0,0 +1,10 @@
+const countElements = arr => arr.length;
+
+const arr1 = [1, 2, 3, 4, 5];
+console.log(countElements(arr1)); // 5
+
+const arr2 = [7, 8, 9, 10, 11, 12, 13, 14, 15];
+console.log(countElements(arr2)); // 9
+
+// Time complexity: O(1)
+// Space complexity: O(1)

DSA-Assignments/week 1/Arrays 1/intersectionOfTwoArrays.js

@@ -0,0 +1,24 @@
+const intersectionOfTwoArray = (arr1, arr2) => {
+  const mySet = new Set(arr2);
+
+  const intersectionArray = [];
+
+  for (let i = 0; i < arr1.length; i++) {
+    if (mySet.has(arr1[i])) {
+      intersectionArray.push(arr1[i]);
+    }
+  }
+
+  return intersectionArray;
+};
+
+const arr1 = [1, 2, 3, 4, 5];
+const arr2 = [4, 5, 6, 7, 8];
+console.log(intersectionOfTwoArray(arr1, arr2)); // [4, 5]
+
+const arr3 = [1, 2, 3, 4, 5];
+const arr4 = [5, 4, 3, 2, 1];
+console.log(intersectionOfTwoArray(arr3, arr4)); // [1, 2, 3, 4, 5]
+
+// Time complexity: O(N)
+// Space complexity: O(N)

DSA-Assignments/week 1/Arrays 1/minAndMax.js

@@ -0,0 +1,12 @@
+const sumOfMinAndMaxOfArray = (arr) => {
+  return Math.max(...arr) + Math.min(...arr);
+};
+
+const arr1 = [5, 2, 9, 1, 7];
+console.log(sumOfMinAndMaxOfArray(arr1)); // 10
+
+const arr2 = [-10, 0, 100, -50, 20];
+console.log(sumOfMinAndMaxOfArray(arr2)); // 50
+
+// Time complexity: O(N)
+// Space complexity: O(1)

DSA-Assignments/week 1/Arrays 1/nonDuplicateElement.js

@@ -0,0 +1,24 @@
+const nonDuplicateElement = (arr) => {
+  const myMap = new Map();
+
+  for (let i = 0; i < arr.length; i++) {
+    if (myMap.has(arr[i])) {
+      myMap.set(arr[i], myMap.get(arr[i]) + 1);
+    } else {
+      myMap.set(arr[i], 1);
+    }
+  }
+
+  for (let [key, value] of myMap) {
+    if (value === 1) return key;
+  }
+};
+
+const arr1 = [5, 2, 3, 2, 5];
+console.log(nonDuplicateElement(arr1)); // 3
+
+const arr2 = [-1, -1, -2, -2, -3];
+console.log(nonDuplicateElement(arr2)); // -3
+
+// Time complexity: O(N)
+// Space complexity: O(N)

DSA-Assignments/week 1/Arrays 1/pairOfSum.js

@@ -0,0 +1,38 @@
+// const pairOfSum = (arr, S) => {
+//   const pairs = [];
+
+//   for (let i = 0; i < arr.length - 1; i++) {
+//     for (let j = i + 1; j < arr.length; j++) {
+//       const sum = arr[i] + arr[j];
+//       if (sum === S) pairs.push([arr[i], arr[j]]);
+//     }
+//   };
+
+//   return pairs;
+// }
+
+const pairOfSum = (arr, S) => {
+  const mySet = new Set();
+  const pairs = [];
+
+  for (let i = 0; i < arr.length; i++) {
+    const compliment = S - arr[i];
+    if (mySet.has(compliment)) {
+      pairs.push([compliment, arr[i]]);
+    }
+    mySet.add(arr[i]);
+  }
+
+  return pairs;
+};
+
+const arr1 = [2, 4, 6, 8, 10];
+const S1 = 12;
+console.log(pairOfSum(arr1, S1)); // [ [ 2, 10 ], [ 4, 8 ] ]
+
+const arr2 = [1, 1, 1, 1, 1];
+const S2 = 2;
+console.log(pairOfSum(arr2, S2)); // [ [ 1, 1 ], [ 1, 1 ], [ 1, 1 ], [ 1, 1 ], [ 1, 1 ], [ 1, 1 ], [ 1, 1 ], [ 1, 1 ], [ 1, 1 ], [ 1, 1 ] ]
+
+// Time complexity: O(N)
+// Space complexity: O(N)

DSA-Assignments/week 1/Arrays 2/deleteElements.js

@@ -0,0 +1,13 @@
+const deleteElementInArray = (arr) => {
+  const newArr = arr.filter((ele) => ele % 2 !== 0 && ele % 3 !== 0);
+  return newArr;
+};
+
+const arr1 = [1, 2, 3, 4, 5, 6, 7, 8, 9];
+console.log(deleteElementInArray(arr1)); // [1, 5, 7]
+
+const arr2 = [9, 12, 15, 18, 21];
+console.log(deleteElementInArray(arr2)); // []
+
+// Time complexity: O(N)
+// Space complexity: O(N)

DSA-Assignments/week 1/Arrays 2/oldKeyNewKey.js

@@ -0,0 +1,19 @@
+const oldKeyNewKey = (arr, oldKey, newKey) => {
+  for (let i = 0; i < arr.length; i++) {
+    if (arr[i] === oldKey) arr[i] = newKey;
+  };
+  return arr;
+};
+
+const arr1 = [1, 2, 3, 2, 4, 2, 5];
+const oldKey1 = 2;
+const newKey1 = 6;
+console.log(oldKeyNewKey(arr1, oldKey1, newKey1)); // [1, 6, 3, 6, 4, 6, 5]
+
+const arr2 = [5, 5, 5, 5];
+const oldKey2 = 5;
+const newKey2 = 2;
+console.log(oldKeyNewKey(arr2, oldKey2, newKey2)); // [2, 2, 2, 2]
+
+// Time complexity: O(N)
+// Space complexity: O(1)

DSA-Assignments/week 1/Arrays 2/productOfSubArray.js

@@ -0,0 +1,29 @@
+const maxProductOfSubArray = (N, arr) => {
+  let maxProduct = arr[0];
+  let minProduct = arr[0];
+  let result = arr[0];
+
+  for (let i = 1; i < N; i++) {
+    if (arr[i] < 0) {
+      [maxProduct, minProduct] = [minProduct, maxProduct];
+    }
+
+    maxProduct = Math.max(maxProduct * arr[i], arr[i]);
+    minProduct = Math.min(minProduct * arr[i], arr[i]);
+
+    result = Math.max(result, maxProduct);
+  }
+
+  return result;
+};
+
+const arr1 = [2, 3, -2, 4, 5];
+const N1 = 5;
+console.log(maxProductOfSubArray(N1, arr1)); // 20
+
+const arr2 = [-1, -2, -3, -4];
+const N2 = 4;
+console.log(maxProductOfSubArray(N2, arr2)); // 24
+
+// Time complexity: O(N);
+// Space complexity: O(1)

DSA-Assignments/week 1/Arrays 2/sumOfTwoMatrix.js

@@ -0,0 +1,66 @@
+function getInputArray(rows, cols, elements) {
+  elements = elements.split(',').map(Number);
+  let index = 0;
+  const matrix = [];
+  for (let i = 0; i < rows; i++) {
+    const row = [];
+    for (let j = 0; j < cols; j++) {
+      row.push(elements[index])
+      index++;
+    }
+    matrix.push(row)
+  }
+  return matrix;
+}
+
+const calculateSumOfArrays = (arr1, arr2) => {
+  const row1 = arr1.length;
+  const col1 = arr1[0].length;
+  const row2 = arr2.length;
+  const col2 = arr2[0].length;
+
+  if (!((row1 === row2) && (col1 === col2))) {
+    return "Arrays must have the same dimensions";
+  }
+
+  let result = [];
+  for (let i = 0; i < arr1.length; i++) {
+    let row = [];
+    for (let j = 0; j < arr1[i].length; j++) {
+      const sum = arr1[i][j] + arr2[i][j];
+      row.push(sum)
+    }
+    result.push(row);
+  }
+
+  return result;
+}
+
+const rows1 = 2;
+const cols1 = 3;
+const elements1 = '1, 2, 3, 4, 5, 6';
+
+const rows2 = 2;
+const cols2 = 3;
+const elements2 = '7, 8, 9, 10, 11, 12';
+
+const arr1 = getInputArray(rows1, cols1, elements1);
+const arr2 = getInputArray(rows2, cols2, elements2);
+
+console.log(calculateSumOfArrays(arr1, arr2)); // [ [ 8, 10, 12 ], [ 14, 16, 18 ] ]
+
+const rows3 = 2;
+const cols3 = 2;
+const elements3 = '1, 2, 3, 4';
+
+const rows4 = 2;
+const cols4 = 2;
+const elements4 = '5, 6, 7, 8';
+
+const arr3 = getInputArray(rows3, cols3, elements3);
+const arr4 = getInputArray(rows4, cols4, elements4);
+
+console.log(calculateSumOfArrays(arr3, arr4)); // [ [ 6, 8 ], [ 10, 12 ] ]
+
+// Time complexity: O(N^2)
+// Space complexity: O(N^2)

DSA-Assignments/week 1/Arrays 2/transposeAMatrix.js

@@ -0,0 +1,60 @@
+/*
+1 2
+3 4
+
+1 3
+2 4
+
+1 2 3 4
+5 6 7 8
+
+1 5
+2 6
+3 7
+4 8
+*/
+function getInputArray(rows, cols, elements) {
+  elements = elements.split(" ").map(Number);
+  let index = 0;
+  const matrix = [];
+  for (let i = 0; i < rows; i++) {
+    const row = [];
+    for (let j = 0; j < cols; j++) {
+      row.push(elements[index]);
+      index++;
+    }
+    matrix.push(row);
+  }
+  return matrix;
+}
+
+const transposeAMatrix = (matrix) => {
+  const rows = matrix.length;
+  const cols = matrix[0].length;
+
+  let output = "";
+
+  for (let i = 0; i < cols; i++) {
+    for (let j = 0; j < rows; j++) {
+      output += matrix[j][i] + " ";
+    }
+  }
+  return output;
+};
+
+const rows1 = 2;
+const cols1 = 2;
+const elements1 = "1 2 3 4";
+
+const matrix1 = getInputArray(rows1, cols1, elements1);
+console.log(transposeAMatrix(matrix1)); // 1 3 2 4
+
+const rows2 = 2;
+const cols2 = 4;
+const elements2 = "1 2 3 4 5 6 7 8";
+
+const matrix2 = getInputArray(rows2, cols2, elements2);
+console.log(transposeAMatrix(matrix2)); // 1 5 2 6 3 7 4 8
+
+// Time complexity: O(N^2)
+// Space complexity: O(1)

DSA-Assignments/week 1/Intro to DSA/isLeapYear.js

@@ -0,0 +1,17 @@
+function isLeapYear(year) {
+  return (year % 4 == 0 && year % 100 != 0) || year % 400 == 0;
+}
+
+function checkLeapYear() {
+  const year = prompt("Please enter a year");
+  if (!year) {
+    prompt("Please enter a year");
+    return;
+  }
+  return alert(isLeapYear(year) ? "Yes" : "No");
+}
+
+checkLeapYear();
+
+// Time complexity: O(1)
+// Space complexity: O(1)

DSA-Assignments/week 1/Intro to DSA/isPalindrome.js

@@ -0,0 +1,27 @@
+function reversedNumber(num) {
+  let reversedNum = 0;
+  while (num !== 0) {
+    let remainder = num % 10;
+    reversedNum = reversedNum * 10 + remainder;
+    num = parseInt(num / 10);
+  }
+  return reversedNum;
+}
+
+function isPalindrome(num) {
+  const reversedNum = reversedNumber(num);
+  return num === reversedNum;
+}
+
+function checkPalindrome() {
+  const num = prompt("Please enter a number");
+  if (!num) {
+    prompt("Please enter a number");
+  }
+  alert(isPalindrome(num) ? "Yes" : "No");
+}
+
+checkPalindrome();
+
+// Time complexity: O(log(N))
+// Space complexity: O(1)

DSA-Assignments/week 1/Intro to DSA/oddEven.js

@@ -0,0 +1,14 @@
+const isEvenOrOdd = num => num % 2 === 0;
+
+const checkEvenOrOdd = () => {
+  const num = prompt('Please enter a number');
+  if (!num) {
+    prompt('Please enter a number');
+  }
+  return alert(isEvenOrOdd(num) ? "Even" : "Odd");
+}
+
+checkEvenOrOdd();
+
+// Time complexity: O(1)
+// Space complexity: O(1)

DSA-Assignments/week 1/Intro to DSA/productOfHalfHCFAndLCM.js

@@ -0,0 +1,19 @@
+const productOfHCFAndLCM = (num1, num2) => {
+  let firstNumber = num1 > num2 ? num1 : num2;
+  let secondNumber = num1 > num2 ? num2 : num1;
+
+  while (secondNumber !== 0) {
+    let temp = secondNumber;
+    secondNumber = firstNumber % secondNumber;
+    firstNumber = temp;
+  }
+
+  const hcf = firstNumber;
+
+  const lcm = (num1 * num2) / hcf;
+
+  return lcm * hcf;
+};
+
+// Time complexity: O(log(N))
+// Space complexity: O(1)