Merge pull request #48 from harisdev-netizen/harisdev-branch

Harisdev-branch

Author: devvsakib

L-A/0007 The Skyline Problem/README.md

@@ -0,0 +1,91 @@
+# 0005 Trapping Rain Water ( L-A )
+
+## Problem
+
+A city's skyline is the outer contour of the silhouette formed by all the buildings in that city when viewed from a distance. Given the locations and heights of all the buildings, return the skyline formed by these buildings collectively.
+
+The geometric information of each building is given in the array `buildings` where `buildings[i] = [lefti, righti, heighti]`:
+
+- `lefti` is the x coordinate of the left edge of the ith building.
+- `righti` is the x coordinate of the right edge of the ith building.
+- `heighti` is the height of the ith building.
+
+You may assume all buildings are perfect rectangles grounded on an absolutely flat surface at height 0.
+
+## Example 1
+
+```
+Input: buildings = [[2,9,10],[3,7,15],[5,12,12],[15,20,10],[19,24,8]]
+Output: [[2,10],[3,15],[7,12],[12,0],[15,10],[20,8],[24,0]]
+Explanation:
+Figure A shows the buildings of the input.
+Figure B shows the skyline formed by those buildings. The red points in figure B represent the key points in the output list.
+```
+
+## Solution Pseudocode
+
+```javascript
+Function getSkyline(buildings):
+    // base case
+    if (length(buildings) == 1):
+        return [(buildings[0].left, buildings[0].height), (buildings[0].right, 0)]
+
+    // divide the buildings into two groups
+    mid = length(buildings) // 2
+    left = getSkyline(buildings[:mid])
+    right = getSkyline(buildings[mid:])
+
+    // merge the two groups
+    return merge(left, right)
+
+Function merge(left, right):
+    // initialize the pointers and the result array
+    i, j = 0, 0
+    result = []
+    left_height, right_height = 0, 0
+    // merge the two lists
+    while (i < len(left) and j < len(right)):
+        if (left[i][0] < right[j][0]):
+            x = left[i][0]
+            left_height = left[i][1]
+            height = max(left_height, right_height)
+            result.append((x, height))
+            i += 1
+        else:
+            x = right[j][0]
+            right_height = right[j][1]
+            height = max(left_height, right_height)
+            result.append((x, height))
+            j += 1
+    // append the remaining points from left or right
+    while (i < len(left)):
+        result.append(left[i])
+        i += 1
+    while (j < len(right)):
+        result.append(right[j])
+        j += 1
+
+    return result
+
+```
+
+## How it works
+- The `getSkyline` function is the main function that takes in a list of buildings as input and returns the skyline as a list of points. The function first checks if there is only one building in the list, in which case it returns two points representing the left and right boundaries of the building.
+- If there are more than one building in the list, the function recursively divides the buildings into two groups using the midpoint, and calls itself on each group. The results from the two recursive calls are then merged using the `merge` function.
+- The `merge` function takes in two lists of points representing the skylines of the left and right groups and merges them into a single list. The function initializes two pointers, `i` and `j`, to 0 and sets `left_height` and `right_height` to 0. The `result` array is used to store the merged skyline.
+- The function then uses a while loop to iterate over the two input lists. At each iteration, it compares the x-coordinates of the points at the current positions of the two pointers. If the x-coordinate of the point in the left list is less than the x-coordinate of the point in the right list, it means that the left building is closer to the viewer, so the function uses the left building's height to update the `left_height` variable and calculates the maximum height between `left_height` and `right_height`. The function then appends a new point with the x-coordinate and maximum height to the `result` array, and increments the `i` pointer.
+- If the x-coordinate of the point in the right list is less than or equal to the x-coordinate of the point in the left list, it means that the right building is closer to the viewer, so the function uses the right building's height to update the `right_height` variable
+
+## References
+
+- [LeetCode](https://leetcode.com/problems/the-skyline-problem/)
+
+## Problem Added By
+
+- [Haris](https://github.com/harisdev-netizen)
+
+## Contributing
+
+Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.
+
+Please make sure to update tests as appropriate.

L-A/0007 The Skyline Problem/skyline.js

@@ -0,0 +1,97 @@
+class Heap {
+  constructor(compareFunc) {
+    this.compare = compareFunc || ((a, b) => a - b);
+    this.elements = [];
+  }
+
+  get size() {
+    return this.elements.length;
+  }
+
+  get top() {
+    return this.elements[0];
+  }
+
+  push(element) {
+    this.elements.push(element);
+    this.heapifyUp();
+  }
+
+  pop() {
+    const top = this.elements[0];
+    const bottom = this.elements.pop();
+    if (this.elements.length > 0) {
+      this.elements[0] = bottom;
+      this.heapifyDown();
+    }
+    return top;
+  }
+
+  heapifyUp() {
+    let current = this.elements.length - 1;
+    while (current > 0) {
+      const parent = Math.floor((current - 1) / 2);
+      if (this.compare(this.elements[current], this.elements[parent]) < 0) {
+        [this.elements[current], this.elements[parent]] = [this.elements[parent], this.elements[current]];
+        current = parent;
+      } else {
+        break;
+      }
+    }
+  }
+
+  heapifyDown() {
+    let current = 0;
+    while (current < this.elements.length) {
+      let child = null;
+      const left = current * 2 + 1;
+      const right = current * 2 + 2;
+      if (left < this.elements.length && this.compare(this.elements[left], this.elements[current]) < 0) {
+        child = left;
+      }
+      if (right < this.elements.length && this.compare(this.elements[right], this.elements[current]) < 0
+          && this.compare(this.elements[right], this.elements[left]) < 0) {
+        child = right;
+      }
+      if (child !== null) {
+        [this.elements[current], this.elements[child]] = [this.elements[child], this.elements[current]];
+        current = child;
+      } else {
+        break;
+      }
+    }
+  }
+}
+
+function getSkyline(buildings) {
+  const n = buildings.length;
+  const criticalPoints = new Heap((a, b) => a[0] !== b[0] ? a[0] - b[0] : b[1] - a[1]);
+  for (let i = 0; i < n; i++) {
+    const [left, right, height] = buildings[i];
+    criticalPoints.push([left, -height, i]);
+    criticalPoints.push([right, height, i]);
+  }
+  const activeBuildings = new Heap((a, b) => b[1] - a[1]);
+  const skyline = [[0, 0]];
+  while (criticalPoints.size > 0) {
+    const [x, h, i] = criticalPoints.top;
+    const isStart = h < 0;
+    const height = Math.abs(h);
+    if (isStart) {
+      activeBuildings.push([buildings[i][2], buildings[i][1]]);
+    } else {
+      activeBuildings.elements.forEach(([ah, ar], j) => {
+        if (j === i) {
+          activeBuildings.elements[j] = activeBuildings.elements[activeBuildings.size - 1];
+          activeBuildings.elements.pop();
+          activeBuildings.heapifyDown();
+          return;
+        }
+        if (ar > buildings[i][0]) {
+          skyline.push([x, Math.min(height, ah)]);
+          if (ar > buildings[i][1]) {
+            activeBuildings.elements[j][1] = buildings[i][1];
+            activeBuildings.heapifyDown();
+          }
+        }
+    });

L-A/0008 Longest Common Subsequence ( L-A )/README.md

@@ -0,0 +1,83 @@
+# 0005 Longest Common Subsequence ( L-A )
+
+## Problem
+
+Given two strings, find the length of their longest common subsequence (LCS). A subsequence is a sequence that can be derived from another sequence by deleting some or no elements without changing the order of the remaining elements.
+
+## Example 1
+
+```
+Input:
+str1 = "ABCDGH"
+str2 = "AEDFHR"
+
+Output:
+The longest common subsequence is "ADH" with a length of 3.
+
+Input:
+str1 = "AGGTAB"
+str2 = "GXTXAYB"
+
+Output:
+The longest common subsequence is "GTAB" with a length of 4.
+```
+
+## Solution Pseudocode
+
+```javascript
+function longestCommonSubsequence(str1, str2) {
+  const m = str1.length;
+  const n = str2.length;
+
+  // Initialize a 2D array with 0
+  const lcs = Array(m + 1)
+    .fill()
+    .map(() => Array(n + 1).fill(0));
+
+  // Fill the 2D array with LCS lengths
+  for (let i = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      if (str1[i - 1] === str2[j - 1]) {
+        lcs[i][j] = lcs[i - 1][j - 1] + 1;
+      } else {
+        lcs[i][j] = Math.max(lcs[i - 1][j], lcs[i][j - 1]);
+      }
+    }
+  }
+
+  // Return the length of LCS
+  return lcs[m][n];
+}
+
+// Example usage
+const str1 = "ABCDGH";
+const str2 = "AEDFHR";
+const result = longestCommonSubsequence(str1, str2);
+console.log(result); // Output: 3
+
+// Another example
+const str3 = "AGGTAB";
+const str4 = "GXTXAYB";
+const result2 = longestCommonSubsequence(str3, str4);
+console.log(result2); // Output: 4
+```
+
+## How it works
+
+- The code returns an object with two properties: `length`, which is the length of the longest common subsequence, and `sequence`, which is the actual subsequence itself.
+- It also includes a section of code to trace back the 2D array and find the actual LCS string.
+- The time complexity of this algorithm is O(mn), where m and n are the lengths of the input strings.
+
+## References
+
+- [Google](https://www.google.com/search?client=opera&q=Longest+Common+Subsequence&sourceid=opera&ie=UTF-8&oe=UTF-8)
+
+## Problem Added By
+
+- [Haris](https://github.com/harisdev-netizen)
+
+## Contributing
+
+Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.
+
+Please make sure to update tests as appropriate.

L-A/0008 Longest Common Subsequence ( L-A )/longestCommonSubsequence.js

@@ -0,0 +1,54 @@
+function longestCommonSubsequence(str1, str2) {
+  const m = str1.length;
+  const n = str2.length;
+
+  // Initialize a 2D array with 0
+  const lcs = Array(m + 1)
+    .fill()
+    .map(() => Array(n + 1).fill(0));
+
+  // Fill the 2D array with LCS lengths
+  for (let i = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      if (str1[i - 1] === str2[j - 1]) {
+        lcs[i][j] = lcs[i - 1][j - 1] + 1;
+      } else {
+        lcs[i][j] = Math.max(lcs[i - 1][j], lcs[i][j - 1]);
+      }
+    }
+  }
+
+  // Find the LCS string by tracing back the 2D array
+  let i = m;
+  let j = n;
+  let lcsStr = "";
+
+  while (i > 0 && j > 0) {
+    if (str1[i - 1] === str2[j - 1]) {
+      lcsStr = str1[i - 1] + lcsStr;
+      i--;
+      j--;
+    } else if (lcs[i - 1][j] > lcs[i][j - 1]) {
+      i--;
+    } else {
+      j--;
+    }
+  }
+
+  return {
+    length: lcs[m][n],
+    sequence: lcsStr,
+  };
+}
+
+// Example usage
+const str1 = "ABCDGH";
+const str2 = "AEDFHR";
+const result = longestCommonSubsequence(str1, str2);
+console.log(result); // Output: { length: 3, sequence: 'ADH' }
+
+// Another example
+const str3 = "AGGTAB";
+const str4 = "GXTXAYB";
+const result2 = longestCommonSubsequence(str3, str4);
+console.log(result2); // Output: { length: 4, sequence: 'GTAB' }