diff --git a/CODE_OF_CONDUCT.md b/CODE_OF_CONDUCT.md
new file mode 100644
index 0000000..18c9147
--- /dev/null
+++ b/CODE_OF_CONDUCT.md
@@ -0,0 +1,128 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, religion, or sexual identity
+and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+ and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the
+ overall community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or
+ advances of any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email
+ address, without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+ professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official e-mail address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+.
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series
+of actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or
+permanent ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior, harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within
+the community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.0, available at
+https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.
+
+Community Impact Guidelines were inspired by [Mozilla's code of conduct
+enforcement ladder](https://github.com/mozilla/diversity).
+
+[homepage]: https://www.contributor-covenant.org
+
+For answers to common questions about this code of conduct, see the FAQ at
+https://www.contributor-covenant.org/faq. Translations are available at
+https://www.contributor-covenant.org/translations.
diff --git a/L-A/0004 Candy ( L-A )/README.md b/L-A/0004 Candy ( L-A )/README.md
new file mode 100644
index 0000000..f7ec0fa
--- /dev/null
+++ b/L-A/0004 Candy ( L-A )/README.md
@@ -0,0 +1,68 @@
+# 0004 Candy ( L-A )
+
+## Problem
+
+There are n children standing in a line. Each child is assigned a rating value given in the integer array ratings.
+
+You are giving candies to these children subjected to the following requirements:
+- Each child must have at least one candy.
+- Children with a higher rating get more candies than their neighbors.
+
+Return the minimum number of candies you need to have to distribute the candies to the children.
+
+## Test Case
+
+```javascript
+Input: ratings = [1,0,2]
+Output: 5
+Explanation: You can allocate to the first, second and third child with 2, 1, 2 candies respectively.
+```
+
+## Solution
+
+```javascript
+var candy = function(ratings) {
+ const candies = ratings.map(() => 1);
+ const len = ratings.length;
+ if (len <= 1) return len;
+
+ for (let index = 1; index < len; index++) {
+ if (ratings[index] > ratings[index-1]) {
+ candies[index] = candies[index-1] + 1;
+ }
+ }
+
+ let sum = candies[len-1];
+ for (let index = len-2; index >= 0; index--) {
+ if (ratings[index] > ratings[index+1] && candies[index] <= candies[index+1]) {
+ candies[index] = candies[index+1] + 1;
+ }
+ sum += candies[index];
+ }
+
+ return sum;
+};
+```
+
+## How it works
+
+- Given an array of integers representing ratings of candy, the goal is to distribute minimum candies among children such that a child with a higher rating gets more candies than their neighbor with a lower rating.
+- The code first initializes a new array called `candies` with the same length as the input `ratings` array, and fills it with ones. This means that initially, each child will receive at least one candy.
+- Next, the code checks if the input `ratings` array has a length of 1 or less, in which case the function simply returns the length of the array.
+- Then, the code loops through the input `ratings` array, starting from the second element, and compares each element to the previous element. If the current element has a higher rating than the previous element, the corresponding element in the `candies` array is updated to be one more than the previous element's value. This ensures that children with higher ratings receive more candies than their neighbors with lower ratings.
+- After that, the code loops through the `candies` array again, this time starting from the second-to-last element and going backwards. For each element, the code checks if it has a higher rating than its next neighbor and if its current number of candies is less than or equal to its next neighbor's number of candies. If both conditions are true, the current element's number of candies is updated to be one more than its next neighbor's number of candies. This makes sure that the distribution of candies is optimal and the minimum number of candies are used.
+- Finally, the code calculates the total number of candies distributed by summing up all the elements in the `candies` array and returns the sum.
+
+## References
+
+- [LeetCode](https://leetcode.com/problems/candy/)
+
+## 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.
diff --git a/L-A/0004 Candy ( L-A )/candy.js b/L-A/0004 Candy ( L-A )/candy.js
new file mode 100644
index 0000000..1e4fa15
--- /dev/null
+++ b/L-A/0004 Candy ( L-A )/candy.js
@@ -0,0 +1,27 @@
+function candy(ratings) {
+ const candies = new Array(ratings.length).fill(1); // initialize candies array with 1 for each child
+ let sum = candies.reduce((acc, val) => acc + val, 0); // sum up initial candies
+
+ // update candies for increasing ratings from left to right
+ for (let i = 1; i < ratings.length; i++) {
+ if (ratings[i] > ratings[i - 1]) {
+ candies[i] = candies[i - 1] + 1;
+ sum += candies[i] - 1; // add the extra candies used to the sum
+ }
+ }
+
+ // update candies for decreasing ratings from right to left
+ for (let i = ratings.length - 2; i >= 0; i--) {
+ if (ratings[i] > ratings[i + 1] && candies[i] <= candies[i + 1]) {
+ candies[i] = candies[i + 1] + 1;
+ sum += candies[i] - 1; // add the extra candies used to the sum
+ }
+ }
+
+ return sum;
+}
+
+// We can test the function with some sample inputs
+console.log(candy([1,0,2]));
+console.log(candy([1,2,2]));
+console.log(candy([1,3,4,5,2]));
\ No newline at end of file
diff --git a/L-A/0005 Trapping Rain Water ( L-A )/README.md b/L-A/0005 Trapping Rain Water ( L-A )/README.md
new file mode 100644
index 0000000..1f07cfc
--- /dev/null
+++ b/L-A/0005 Trapping Rain Water ( L-A )/README.md
@@ -0,0 +1,68 @@
+# 0005 Trapping Rain Water ( L-A )
+
+## Problem
+
+Given n non-negative integers representing an elevation map where the width of each bar is 1, compute how much water it can trap after raining.
+
+## Example 1
+
+```
+Input: height = [0,1,0,2,1,0,1,3,2,1,2,1]
+Output: 6
+Explanation: The above elevation map (black section) is represented by array [0,1,0,2,1,0,1,3,2,1,2,1]. In this case, 6 units of rain water (blue section) are being trapped.
+```
+
+## Solution
+
+```javascript
+const trap = function (height) {
+ let ans = 0;
+ const size = height.length;
+ let leftMax = height[0];
+ let rightMax = height[size - 1];
+ const leftArr = new Array(size);
+ leftArr[0] = height[0];
+ const rightArr = new Array(size);
+ rightArr[size - 1] = height[size - 1];
+
+ for (let i = 1; i < size; i++) {
+ leftMax = Math.max(leftMax, height[i]);
+ leftArr[i] = leftMax;
+ }
+
+ for (let k = size - 2; k >= 0; k--) {
+ rightMax = Math.max(rightMax, height[k]);
+ rightArr[k] = rightMax;
+ }
+
+ for (let j = 0; j < size; j++) {
+ ans += Math.max(Math.min(leftArr[j], rightArr[j]) - height[j], 0);
+ }
+
+ return ans;
+};
+
+```
+
+## How it works
+
+- The function `trap` takes an array of integers `height` as input and returns an integer representing the amount of water that can be trapped.
+- The function initializes the variables `ans`, `size`, `leftMax`, and `rightMax` to 0, the length of the `height` array, and the maximum heights to the left and right of the array, respectively. It also initializes two arrays leftArr and rightArr to store the maximum height to the left and right of each index, respectively.
+- The function then loops through the `height` array from left to right and stores the maximum height to the left of each index in the `leftArr` array using the variable `leftMax`.
+- The function loops through the `height` array from right to left and stores the maximum height to the right of each index in the `rightArr` array using the variable `rightMax`.
+- The function loops through the `height` array again and calculates the amount of water that can be trapped at each index by taking the minimum of the maximum heights to the left and right of the index, subtracting the height at the index, and taking the maximum with 0 to avoid negative values. The calculated value is added to the `ans` variable.
+- The function returns the final `ans` value.
+
+## References
+
+- [LeetCode](https://leetcode.com/problems/trapping-rain-water/)
+
+## 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.
diff --git a/L-A/0005 Trapping Rain Water ( L-A )/trappingRainWater.js b/L-A/0005 Trapping Rain Water ( L-A )/trappingRainWater.js
new file mode 100644
index 0000000..7ade059
--- /dev/null
+++ b/L-A/0005 Trapping Rain Water ( L-A )/trappingRainWater.js
@@ -0,0 +1,34 @@
+/**
+ * @param {number[]} height - Array of heights.
+ * @return {number} - Amount of water that can be trapped.
+ */
+
+const trap = function (height) {
+ let ans = 0;
+ const size = height.length;
+ let leftMax = height[0];
+ let rightMax = height[size - 1];
+ const leftArr = new Array(size);
+ leftArr[0] = height[0];
+ const rightArr = new Array(size);
+ rightArr[size - 1] = height[size - 1];
+
+ // Calculate the maximum height to the left of each index and store it in the leftArr.
+ for (let i = 1; i < size; i++) {
+ leftMax = Math.max(leftMax, height[i]);
+ leftArr[i] = leftMax;
+ }
+
+ // Calculate the maximum height to the right of each index and store it in the rightArr.
+ for (let k = size - 2; k >= 0; k--) {
+ rightMax = Math.max(rightMax, height[k]);
+ rightArr[k] = rightMax;
+ }
+
+ // Calculate the amount of water that can be trapped at each index and add it to the answer.
+ for (let j = 0; j < size; j++) {
+ ans += Math.max(Math.min(leftArr[j], rightArr[j]) - height[j], 0);
+ }
+
+ return ans;
+};
diff --git a/L-A/0006 Wild Card Matching ( L-A )/README.md b/L-A/0006 Wild Card Matching ( L-A )/README.md
new file mode 100644
index 0000000..d788476
--- /dev/null
+++ b/L-A/0006 Wild Card Matching ( L-A )/README.md
@@ -0,0 +1,68 @@
+# 0006 Wild Card Matching ( L-A )
+
+## Problem
+
+Given n non-negative integers representing an elevation map where the width of each bar is 1, compute how much water it can trap after raining.
+
+## Example 1
+
+```
+Input: s = "aa", p = "a"
+Output: false
+Explanation: "a" does not match the entire string "aa".
+```
+
+## Solution
+
+```javascript
+function isMatch(s, p) {
+ const memo = {};
+ return dp(0, 0, memo);
+
+ function dp(i, j, memo) {
+ const key = `${i}-${j}`;
+
+ if (memo.hasOwnProperty(key)) {
+ return memo[key];
+ }
+
+ if (j === p.length) {
+ return i === s.length;
+ }
+
+ const firstMatch = i < s.length && (p[j] === s[i] || p[j] === "?");
+
+ if (p[j] === "*") {
+ memo[key] =
+ dp(i, j + 1, memo) ||
+ (firstMatch && dp(i + 1, j, memo));
+ } else {
+ memo[key] = firstMatch && dp(i + 1, j + 1, memo);
+ }
+
+ return memo[key];
+ }
+}
+
+```
+
+## How it works
+- This solution uses dynamic programming with memoization to efficiently solve the problem. The `dp` function takes two indices (`i` and `j`) to represent the current positions in the string `s` and pattern `p`, respectively, as well as a memoization object (`memo`) to store previous results.
+- The base cases for the recursion are when the pattern is empty (`j === p.length`) and the string is empty (`i === s.length`). In this case, the function returns `true` if the string is empty as well, and ``false` otherwise.
+- If the current character in the pattern is a wildcard (`'*'`), there are two possibilities: either the wildcard matches 0 characters (in which case we move to the next character in the pattern by calling `dp(i, j + 1, memo)`), or the wildcard matches 1 or more characters (in which case we move to the next character in the string by calling `dp(i + 1, j, memo)` if there is a match at the current position). We use the `||` operator to combine these two possibilities, and memoize the result.
+- If the current character in the pattern is not a wildcard, we check if there is a match at the current position (`firstMatch = i < s.length && (p[j] === s[i] || p[j] === '?')`). If there is a match, we move to the next character in both the string and the pattern by calling `dp(i + 1, j + 1, memo)`. We memoize the result and return it.
+- At the end, we call the `dp` function with the initial indices (`0` and `0`) and the memoization object. The result of the function represents whether the string matches the pattern.
+
+## References
+
+- [LeetCode](https://leetcode.com/problems/wildcard-matching/)
+
+## 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.
diff --git a/L-A/0006 Wild Card Matching ( L-A )/wildCardMatching.js b/L-A/0006 Wild Card Matching ( L-A )/wildCardMatching.js
new file mode 100644
index 0000000..abd044b
--- /dev/null
+++ b/L-A/0006 Wild Card Matching ( L-A )/wildCardMatching.js
@@ -0,0 +1,32 @@
+function isMatch(s, p) {
+ const memo = {}; // memoization object to store previous results
+ return dp(0, 0, memo);
+
+ function dp(i, j, memo) {
+ const key = `${i}-${j}`; // key to store and retrieve memoization results
+
+ if (memo.hasOwnProperty(key)) {
+ // check if result has already been computed
+ return memo[key];
+ }
+
+ if (j === p.length) {
+ // if pattern is empty, string must also be empty
+ return i === s.length;
+ }
+
+ const firstMatch = i < s.length && (p[j] === s[i] || p[j] === "?");
+
+ if (p[j] === "*") {
+ // if current character is wildcard
+ memo[key] =
+ dp(i, j + 1, memo) || // match 0 characters
+ (firstMatch && dp(i + 1, j, memo)); // match 1 or more characters
+ } else {
+ // if current character is not a wildcard
+ memo[key] = firstMatch && dp(i + 1, j + 1, memo); // match current characters
+ }
+
+ return memo[key];
+ }
+}
diff --git a/L-A/0007 The Skyline Problem/README.md b/L-A/0007 The Skyline Problem/README.md
new file mode 100644
index 0000000..f86fbcb
--- /dev/null
+++ b/L-A/0007 The Skyline Problem/README.md
@@ -0,0 +1,91 @@
+# 0007 The Skyline Problem ( 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.
diff --git a/L-A/0007 The Skyline Problem/skyline.js b/L-A/0007 The Skyline Problem/skyline.js
new file mode 100644
index 0000000..71c2563
--- /dev/null
+++ b/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();
+ }
+ }
+ });
diff --git a/L-A/0008 Longest Common Subsequence ( L-A )/README.md b/L-A/0008 Longest Common Subsequence ( L-A )/README.md
new file mode 100644
index 0000000..5387f50
--- /dev/null
+++ b/L-A/0008 Longest Common Subsequence ( L-A )/README.md
@@ -0,0 +1,83 @@
+# 0008 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.
diff --git a/L-A/0008 Longest Common Subsequence ( L-A )/longestCommonSubsequence.js b/L-A/0008 Longest Common Subsequence ( L-A )/longestCommonSubsequence.js
new file mode 100644
index 0000000..c06790d
--- /dev/null
+++ b/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' }
diff --git a/L-A/0009 Word Search II ( L-A )/README.md b/L-A/0009 Word Search II ( L-A )/README.md
new file mode 100644
index 0000000..d6625c9
--- /dev/null
+++ b/L-A/0009 Word Search II ( L-A )/README.md
@@ -0,0 +1,78 @@
+# 0009 Word Search II ( 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 findWords(board, words):
+ result = []
+
+ function dfs(i, j, word, visited):
+ if i < 0 or j < 0 or i >= board.length or j >= board[0].length:
+ return
+ if visited[i][j]:
+ return
+ word += board[i][j]
+
+ if words includes word:
+ result.push(word)
+
+ visited[i][j] = true
+
+ dfs(i+1, j, word, visited)
+ dfs(i-1, j, word, visited)
+ dfs(i, j+1, word, visited)
+ dfs(i, j-1, word, visited)
+
+ visited[i][j] = false
+
+ visited = new Array(board.length).fill(false).map(() => new Array(board[0].length).fill(false))
+
+ for i from 0 to board.length-1:
+ for j from 0 to board[0].length-1:
+ dfs(i, j, "", visited)
+
+ return result
+```
+
+## How it works
+
+- We first define a `result` array to store the found words. Then, we define a `dfs` function that takes the current position on the board (`i` and `j`), the current word being built (`word`), and a `visited` array to keep track of visited positions.
+- The function checks if the current position is out of bounds or has already been visited. If either of these conditions are true, the function returns. Otherwise, the function adds the current character to the word, and checks if the word is in the list of target words. If it is, it adds the word to the `result` array.
+- The function then marks the current position as visited and performs a depth-first search on all adjacent positions. After the search is complete, the current position is marked as unvisited.
+- Lastly, we create a `visited` array with the same dimensions as the board, and iterate through each position on the board, calling the `dfs` function with the initial parameters. The function returns the `result` array containing all the found words.
+
+## References
+
+- [LeetCode](https://leetcode.com/problems/word-search-ii/)
+
+## 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.
diff --git a/L-A/0009 Word Search II ( L-A )/wordSearch.js b/L-A/0009 Word Search II ( L-A )/wordSearch.js
new file mode 100644
index 0000000..527e8d7
--- /dev/null
+++ b/L-A/0009 Word Search II ( L-A )/wordSearch.js
@@ -0,0 +1,38 @@
+function findWords(board, words) {
+ const result = []; // array to store found words
+
+ function dfs(i, j, word, visited) {
+ // depth-first search function
+ if (i < 0 || j < 0 || i >= board.length || j >= board[0].length) return; // check if position is out of bounds
+ if (visited[i][j]) return; // check if position has already been visited
+ word += board[i][j]; // add current character to current word
+
+ if (words.includes(word)) {
+ // check if current word is a target word
+ result.push(word); // add word to result array
+ }
+
+ visited[i][j] = true; // mark current position as visited
+
+ // search adjacent positions recursively
+ dfs(i + 1, j, word, visited);
+ dfs(i - 1, j, word, visited);
+ dfs(i, j + 1, word, visited);
+ dfs(i, j - 1, word, visited);
+
+ visited[i][j] = false; // mark current position as unvisited (backtrack)
+ }
+
+ const visited = new Array(board.length)
+ .fill(false)
+ .map(() => new Array(board[0].length).fill(false)); // initialize visited array
+
+ for (let i = 0; i < board.length; i++) {
+ // iterate over each position on the board
+ for (let j = 0; j < board[0].length; j++) {
+ dfs(i, j, "", visited); // perform depth-first search starting at current position
+ }
+ }
+
+ return result; // return array of found words
+}
diff --git a/L-A/0010 Design Cancellable Function (L-A)/Design Cancellable Function.js b/L-A/0010 Design Cancellable Function (L-A)/Design Cancellable Function.js
new file mode 100644
index 0000000..bfe1952
--- /dev/null
+++ b/L-A/0010 Design Cancellable Function (L-A)/Design Cancellable Function.js
@@ -0,0 +1,22 @@
+const cancellable = (generator) => {
+ let cancel;
+ const cancelPromise = new Promise((_, reject) => {
+ cancel = () => reject("Cancelled");
+ });
+ // Every Promise rejection has to be caught.
+ cancelPromise.catch(() => {});
+
+ const promise = (async () => {
+ let next = generator.next();
+ while (!next.done) {
+ try {
+ next = generator.next(await Promise.race([next.value, cancelPromise]));
+ } catch (e) {
+ next = generator.throw(e);
+ }
+ }
+ return next.value;
+ })();
+
+ return [cancel, promise];
+};
diff --git a/L-A/0010 Design Cancellable Function (L-A)/README.md b/L-A/0010 Design Cancellable Function (L-A)/README.md
new file mode 100644
index 0000000..5d88b31
--- /dev/null
+++ b/L-A/0010 Design Cancellable Function (L-A)/README.md
@@ -0,0 +1,74 @@
+# 2650. Design Cancellable Function
+[LeetCode](https://leetcode.com/problems/design-cancellable-function/)
+
+Sometimes you have a long running task, and you may wish to cancel it before it completes. To help with this goal, write a function `cancellable` that accepts a generator object and returns an array of two values: a cancel function and a promise.
+You may assume the generator function will only yield promises. It is your function's responsibility to pass the values resolved by the promise back to the generator. If the promise rejects, your function should throw that error back to the generator.
+If the cancel callback is called before the generator is done, your function should throw an error back to the generator. That error should be the string `"Cancelled"` (Not an `Error` object). If the error was caught, the returned promise should resolve with the next value that was yielded or returned. Otherwise, the promise should reject with the thrown error. No more code should be executed.
+
+When the generator is done, the promise your function returned should resolve the value the generator returned. If, however, the generator throws an error, the returned promise should reject with the error.
+
+An example of how your code would be used:
+```javascript
+function* tasks() {
+ const val = yield new Promise(resolve => resolve(2 + 2));
+ yield new Promise(resolve => setTimeout(resolve, 100));
+ return val + 1; // calculation shouldn't be done.
+}
+const [cancel, promise] = cancellable(tasks());
+setTimeout(cancel, 50);
+promise.catch(console.log); // logs "Cancelled" at t=50ms
+```
+If instead `cancel()` was not called or was called after `t=100ms`, the promise would have resolved 5.
+
+
+## Example 1:
+
+Input:
+```javascript
+generatorFunction = function*() {
+ return 42;
+}
+cancelledAt = 100
+```
+**Output:** `{"resolved": 42}`
+**Explanation:**
+```javascript
+const generator = generatorFunction();
+const [cancel, promise] = cancellable(generator);
+setTimeout(cancel, 100);
+promise.then(console.log); // resolves 42 at t=0ms
+```
+The generator immediately yields 42 and finishes. Because of that, the returned promise immediately resolves 42. Note that cancelling a finished generator does nothing.
+
+## Example 2:
+
+Input:
+```javascript
+generatorFunction = function*() {
+ const msg = yield new Promise(res => res("Hello"));
+ throw `Error: ${msg}`;
+}
+cancelledAt = null
+```
+**Output:** `{"rejected": "Error: Hello"}`
+**Explanation:**
+A promise is yielded. The function handles this by waiting for it to resolve and then passes the resolved value back to the generator. Then an error is thrown which has the effect of causing the promise to reject with the same thrown error.
+
+## Example 3:
+
+Input:
+```javascript
+generatorFunction = function*() {
+ yield new Promise(res => setTimeout(res, 200));
+ return "Success";
+}
+cancelledAt = 100
+```
+**Output:** `{"rejected": "Cancelled"}`
+**Explanation:**
+While the function is waiting for the yielded promise to resolve, cancel() is called. This causes an error message to be sent back to the generator. Since this error is uncaught, the returned promise rejected with this error.
+
+## Constraints:
+
+`cancelledAt == null or 0 <= cancelledAt <= 1000`
+`generatorFunction` returns a generator object
diff --git a/L-A/0011 The Fiscal Code/README.md b/L-A/0011 The Fiscal Code/README.md
new file mode 100644
index 0000000..3465b45
--- /dev/null
+++ b/L-A/0011 The Fiscal Code/README.md
@@ -0,0 +1,57 @@
+# The Fiscal Code
+**[Edabit Problem](https://edabit.com/challenge/Pa2rHJ6KeRBTF28Pg)**
+
+Each person in Italy has an unique identifying ID code issued by the national tax office after the birth registration: the Fiscal Code ([Codice Fiscale](https://en.wikipedia.org/wiki/Italian_fiscal_code_card)).
+
+Given an object containing the personal data of a person (name, surname, gender and date of birth) return the 11 code characters as a string following these steps:
+
+- Generate 3 capital letters from the surname, if it has:
+
+ - At least 3 consonants then the first three consonants are used. (Newman -> NWM).
+ - Less than 3 consonants then vowels will replace missing characters in the same order they appear (Fox -> FXO | Hope -> HPO).
+ - Less than three letters then "X" will take the third slot after the consonant and the vowel (Yu -> YUX).
+
+- Generate 3 capital letters from the name, if it has:
+
+ - Exactly 3 consonants then consonants are used in the order they appear (Matt -> MTT).
+ - More than 3 consonants then first, third and fourth consonant are used (Samantha -> SNT | Thomas -> TMS).
+ - Less than 3 consonants then vowels will replace missing characters in the same order they appear (Bob -> BBO | Paula -> PLA).
+ - Less than three letters then "X" will take the the third slot after the consonant and the vowel (Al -> LAX).
+
+- Generate 2 numbers, 1 letter and 2 numbers from date of birth and gender:
+
+ - Take the last two digits of the year of birth (1985 -> 85).
+ - Generate a letter corresponding to the month of birth (January -> A | December -> T) using the table for conversion included in the code.
+ - For males take the day of birth adding one zero at the start if is less than 10 (any 9th day -> 09 | any 20th day -> 20).
+ - For females take the day of birth and sum 40 to it (any 9th day -> 49 | any 20th day -> 60).
+
+### Examples:
+
+```javascipt
+fiscalCode({
+ name: "Matt",
+ surname: "Edabit",
+ gender: "M",
+ dob: "1/1/1900"
+}) ➞ "DBTMTT00A01"
+
+fiscalCode({
+ name: "Helen",
+ surname: "Yu",
+ gender: "F",
+ dob: "1/12/1950"
+}) ➞ "YUXHLN50T41"
+
+fiscalCode({
+ name: "Mickey",
+ surname: "Mouse",
+ gender: "M",
+ dob: "16/1/1928"
+}) ➞ "MSOMKY28A16"
+```
+
+**Notes:**
+- Code letters must be uppercase.
+- Date of birth is given in D/M/YYYY format.
+- The conversion table for months is already in the starting code.
+- Y is not a vowel.
diff --git a/L-A/0011 The Fiscal Code/TheFiscalCode.js b/L-A/0011 The Fiscal Code/TheFiscalCode.js
new file mode 100644
index 0000000..f1f8a2d
--- /dev/null
+++ b/L-A/0011 The Fiscal Code/TheFiscalCode.js
@@ -0,0 +1,79 @@
+function fiscalCode(data) {
+ const monthsConversion = {
+ '01': 'A', '02': 'B', '03': 'C', '04': 'D', '05': 'E', '06': 'H',
+ '07': 'L', '08': 'M', '09': 'P', '10': 'R', '11': 'S', '12': 'T'
+ };
+
+ // Helper function to generate code for names and surnames
+ function generateCode(name, isSurname) {
+ const vowels = 'AEIOU';
+ let consonants = '';
+ let code = '';
+
+ // Helper function to check if a character is a consonant
+ function isConsonant(char) {
+ return /[BCDFGHJKLMNPQRSTVWXYZ]/.test(char);
+ }
+
+ for (let i = 0; i < name.length && consonants.length < 3; i++) {
+ const char = name[i].toUpperCase();
+ if (isConsonant(char)) {
+ consonants += char;
+ }
+ }
+
+ if (consonants.length < 3) {
+ for (let i = 0; i < name.length && consonants.length < 3; i++) {
+ const char = name[i].toUpperCase();
+ if (vowels.includes(char)) {
+ consonants += char;
+ }
+ }
+ }
+
+ if (consonants.length < 3) {
+ consonants += 'X'.repeat(3 - consonants.length);
+ }
+
+ code = consonants;
+
+ if (isSurname) {
+ code += 'XXX';
+ } else {
+ code += name.length >= 3 ? name[0] + name[2] + name[3] : name + 'XX';
+ }
+
+ return code;
+ }
+
+ const surnameCode = generateCode(data.surname, true);
+ const nameCode = generateCode(data.name, false);
+
+ const year = data.dob.split('/')[2].slice(-2);
+ const month = monthsConversion[data.dob.split('/')[1]];
+ const day = (data.gender === 'F' ? 40 + parseInt(data.dob.split('/')[0]) : parseInt(data.dob.split('/')[0])).toString().padStart(2, '0');
+
+ return `${surnameCode}${nameCode}${year}${month}${day}`;
+}
+
+// Examples
+console.log(fiscalCode({
+ name: "Matt",
+ surname: "Edabit",
+ gender: "M",
+ dob: "1/1/1900"
+})); // ➞ "DBTMTT00A01"
+
+console.log(fiscalCode({
+ name: "Helen",
+ surname: "Yu",
+ gender: "F",
+ dob: "1/12/1950"
+})); // ➞ "YUXHLN50T41"
+
+console.log(fiscalCode({
+ name: "Mickey",
+ surname: "Mouse",
+ gender: "M",
+ dob: "16/1/1928"
+})); // ➞ "MSOMKY28A16"
diff --git a/L-A/0012 SVG Path Data Parser/README.md b/L-A/0012 SVG Path Data Parser/README.md
new file mode 100644
index 0000000..24c40f4
--- /dev/null
+++ b/L-A/0012 SVG Path Data Parser/README.md
@@ -0,0 +1,54 @@
+# SVG Path Data Parser
+[Edabit Problem](https://edabit.com/challenge/ysMrKPGby3FXiYtQn)
+
+A `` element can usually be found inside an `