Best Time to Buy and Sell Stock

Best Time to Buy and Sell Stock/solution.js

@@ -0,0 +1,16 @@
+var maxProfit = function (prices) {
+  let buyPrice = prices[0];
+  let profit = 0;
+
+  for (let i = 0; i < prices.length; i++) {
+    if (buyPrice > prices[i]) {
+      buyPrice = prices[i];
+    }
+    profit = Math.max(profit, prices[i] - buyPrice);
+  }
+
+  return profit;
+};
+
+console.log(maxProfit([7, 1, 5, 3, 6, 4]));
+

Can attend meetings/solution.js

@@ -0,0 +1,11 @@
+function canAttendMeetings(intervals) {
+  intervals.sort((a, b) => a.start - b.start);
+
+  for (let i = 1; i < intervals.length; i++) {
+      if (intervals[i][0] < intervals[i - 1][1]) {
+          return false;
+      }
+  }
+
+  return true;
+}

Climbing stairs/solution.js

@@ -0,0 +1,14 @@
+var climbStairs = function (n) {
+  if (n <= 2) return n;
+
+  let dp = new Array(n + 1).fill(0);
+
+  dp[1] = 1;
+  dp[2] = 2;
+
+  for (let i = 3; i <= n; i++) {
+    dp[i] = dp[i - 1] + dp[i - 2];
+  }
+
+  return dp[n];
+};

Clone Graph/solution.js

@@ -0,0 +1,19 @@
+var cloneGraph = function(node) {
+  if (!node) return null;
+  const visited = new Map();
+
+  const dfs = (node) => {
+      if (visited.has(node)) return visited.get(node);
+
+      const clone = new Node(node.val);
+      visited.set(node, clone);
+
+      for (let neighbor of node.neighbors) {
+          clone.neighbors.push(dfs(neighbor));
+      }
+
+      return clone;
+  };
+
+  return dfs(node);
+};

Coin change/solution.js

@@ -0,0 +1,14 @@
+var coinChange = function(coins, amount) {
+  let minCoins = new Array(amount + 1).fill(amount + 1);
+  minCoins[0] = 0;
+
+  for (let i = 1; i <= amount; i++) {
+      for (let j = 0; j < coins.length; j++) {
+          if (i - coins[j] >= 0) {
+              minCoins[i] = Math.min(minCoins[i], 1 + minCoins[i - coins[j]]);
+          }
+      }
+  }
+
+  return minCoins[amount] !== amount + 1 ? minCoins[amount] : -1;    
+};

Combination sum/solution.js

@@ -0,0 +1,14 @@
+var combinationSum4 = function(nums, target) {
+  const dp = Array(target + 1).fill(0);
+  dp[0] = 1;
+
+  for (let i = 1; i <= target; i++) {
+      for (const num of nums) {
+          if (i - num >= 0) {
+              dp[i] += dp[i - num];
+          }
+      }
+  }
+
+  return dp[target];
+};

Container with most water/solution.js

@@ -0,0 +1,17 @@
+var maxArea = function(height) {
+  let maxArea = 0;
+  let left = 0;
+  let right = height.length - 1;
+
+  while (left < right) {
+      maxArea = Math.max(maxArea, (right - left) * Math.min(height[left], height[right]));
+
+      if (height[left] < height[right]) {
+          left++;
+      } else {
+          right--;
+      }
+  }
+
+  return maxArea;    
+};

Contains Duplicate/solution.js

@@ -0,0 +1,13 @@
+function containsDuplicate(nums) {
+  const hashMap = {};
+  for (let i = 0; i < nums.length; i++) {
+    if (hashMap[nums[i]]) {
+      return true;
+    }
+    hashMap[nums[i]] = nums[i];
+  }
+
+  return false;
+}
+
+console.log(containsDuplicate([1, 2, 3, 1]));

Count unreachable pairs/solution.js

@@ -0,0 +1,91 @@
+var countPairs = function(n, edges) {
+  const graph = Array.from({ length: n }, () => []);
+
+  // Build adjacency list
+  for (const [a, b] of edges) {
+      graph[a].push(b);
+      graph[b].push(a);
+  }
+
+  const visited = new Array(n).fill(false);
+
+  // DFS to count size of each connected component
+  const dfs = (node) => {
+      visited[node] = true;
+      let size = 1;
+      for (const neighbor of graph[node]) {
+          if (!visited[neighbor]) {
+              size += dfs(neighbor);
+          }
+      }
+      return size;
+  };
+
+  let totalPairs = 0;
+  let totalNodes = n;
+
+  for (let i = 0; i < n; i++) {
+      if (!visited[i]) {
+          const componentSize = dfs(i);
+          totalPairs += componentSize * (totalNodes - componentSize);
+          totalNodes -= componentSize;
+      }
+  }
+
+  return totalPairs;
+};
+
+
+// using unin find
+
+var countPairs = function(n, edges) {
+  // Step 1: Create Union Find
+  const parent = Array.from({ length: n }, (_, i) => i);
+  const size = Array(n).fill(1); // Size of each component
+
+  const find = (x) => {
+      if (parent[x] !== x) {
+          parent[x] = find(parent[x]); // Path compression
+      }
+      return parent[x];
+  };
+
+  const union = (x, y) => {
+      const rootX = find(x);
+      const rootY = find(y);
+
+      if (rootX === rootY) return; // Already connected
+
+      // Union by size
+      if (size[rootX] < size[rootY]) {
+          parent[rootX] = rootY;
+          size[rootY] += size[rootX];
+      } else {
+          parent[rootY] = rootX;
+          size[rootX] += size[rootY];
+      }
+  };
+
+  // Step 2: Connect nodes
+  for (const [a, b] of edges) {
+      union(a, b);
+  }
+
+  // Step 3: Count sizes of each connected component
+  const count = new Map();
+  for (let i = 0; i < n; i++) {
+      const root = find(i);
+      count.set(root, (count.get(root) || 0) + 1);
+  }
+
+  // Step 4: Calculate unreachable pairs
+  let totalNodes = n;
+  let result = 0;
+
+  for (const sz of count.values()) {
+      result += sz * (totalNodes - sz);
+      totalNodes -= sz;
+  }
+
+  return result;
+};

Counting bits/solution.js

@@ -0,0 +1,7 @@
+var countBits = function(n) {
+  let res = new Array(n + 1).fill(0);
+  for (let i = 1; i <= n; i++) {
+      res[i] = res[i >> 1] + (i & 1);
+  }
+  return res;
+};

Course schedule.js/solution.js

@@ -0,0 +1,32 @@
+function canFinish(numCourses, prerequisites) {
+  const graph = new Map();
+  const inDegree = new Array(numCourses).fill(0);
+
+  // Build graph and in-degree array
+  for (const [course, prereq] of prerequisites) {
+    if (!graph.has(prereq)) graph.set(prereq, []);
+    graph.get(prereq).push(course);
+    inDegree[course]++;
+  }
+
+  // Queue for courses with no prerequisites
+  const queue = [];
+  for (let i = 0; i < numCourses; i++) {
+    if (inDegree[i] === 0) queue.push(i);
+  }
+
+  let finishedCourses = 0;
+
+  while (queue.length > 0) {
+    const current = queue.shift();
+    finishedCourses++;
+
+    const neighbors = graph.get(current) || [];
+    for (const neighbor of neighbors) {
+      inDegree[neighbor]--;
+      if (inDegree[neighbor] === 0) queue.push(neighbor);
+    }
+  }
+
+  return finishedCourses === numCourses;
+}

Decode ways/solution.js

@@ -0,0 +1,23 @@
+var numDecodings = function(s) {
+  if (s[0] === '0') {
+      return 0;
+  }
+
+  const n = s.length;
+  const dp = new Array(n + 1).fill(0);
+  dp[0] = dp[1] = 1;
+
+  for (let i = 2; i <= n; i++) {
+      const one = parseInt(s[i - 1]);
+      const two = parseInt(s.substring(i - 2, i));
+
+      if (1 <= one && one <= 9) {
+          dp[i] += dp[i - 1];
+      }
+      if (10 <= two && two <= 26) {
+          dp[i] += dp[i - 2];
+      }
+  }
+
+  return dp[n];    
+};

EraseOverLapIntervals/solution.js

@@ -0,0 +1,16 @@
+
+var eraseOverlapIntervals = function(intervals) {
+  let res = 0;
+  intervals.sort((a, b) => a[1] - b[1]);
+  let prev_end = intervals[0][1];
+
+  for (let i = 1; i < intervals.length; i++) {
+      if (prev_end > intervals[i][0]) {
+          res++;
+      } else {
+          prev_end = intervals[i][1];
+      }
+  }
+
+  return res;    
+};

Find Minimum in Rotated sorted array/solution.js

@@ -0,0 +1,16 @@
+var findMin = function (nums) {
+  let left = 0;
+  let right = nums.length - 1;
+
+  while (left < right) {
+    const mid = Math.floor((left + right) / 2);
+
+    if (nums[mid] <= nums[right]) {
+      right = mid;
+    } else {
+      left = mid + 1;
+    }
+  }
+
+  return nums[left];
+};

Find building alice and bob/solution.js

@@ -0,0 +1,58 @@
+var leftmostBuildingQueries = function(heights, queries) {
+  const n = heights.length;
+  const st = Array.from({ length: n }, () => Array(20).fill(0));
+  const Log = Array(n + 1).fill(0);
+  Log[0] = -1;
+
+  for (let i = 1; i <= n; i++) {
+      Log[i] = Log[i >> 1] + 1;
+  }
+
+  for (let i = 0; i < n; i++) {
+      st[i][0] = heights[i];
+  }
+
+  for (let i = 1; i < 20; i++) {
+      for (let j = 0; j + (1 << i) <= n; j++) {
+          st[j][i] = Math.max(st[j][i - 1], st[j + (1 << (i - 1))][i - 1]);
+      }
+  }
+
+  const res = [];
+
+  for (let i = 0; i < queries.length; i++) {
+      let [l, r] = queries[i];
+      if (l > r) {
+          [l, r] = [r, l];
+      }
+
+      if (l === r) {
+          res.push(l);
+          continue;
+      }
+
+      if (heights[r] > heights[l]) {
+          res.push(r);
+          continue;
+      }
+
+      const maxHeight = Math.max(heights[l], heights[r]);
+      let left = r + 1, right = n, mid;
+
+      while (left < right) {
+          mid = Math.floor((left + right) / 2);
+          const k = Log[mid - r + 1];
+          const maxInRange = Math.max(st[r][k], st[mid - (1 << k) + 1][k]);
+
+          if (maxInRange > maxHeight) {
+              right = mid;
+          } else {
+              left = mid + 1;
+          }
+      }
+
+      res.push(left === n ? -1 : left);
+  }
+
+  return res;
+};