docs: add new LeetCode problem documentation and cleanup formatting

docs/reference/01-reverse-string.mdx

@@ -31,7 +31,6 @@ You must do this by modifying the input array in-place with O(1) extra memory.
  * @param {character[]} s
  * @return {void} Do not return anything, modify s in-place instead.
  */
-
 var reverseString = function(s) {
     let i = 0;
     let j = s.length - 1;

docs/reference/03-3sum.mdx

@@ -0,0 +1,44 @@
+---
+title: '15. 3Sum'
+description: Given an integer array nums, return all the triplets [nums[i], nums[j], nums[k]] such that i != j, i != k, and j != k, and nums[i] + nums[j] + nums[k] == 0
+sidebar:
+  badge: 'Medium'
+---
+
+<Badge variant="accent">Two Pointers</Badge>
+
+::::warning
+Notice that the solution set must not contain duplicate triplets.
+::::
+
+### Example 1:
+- Input: `nums = [-1,0,1,2,-1,-4]`
+- Output: `[[-1,-1,2],[-1,0,1]]`
+- Explanation: `nums[0] + nums[1] + nums[2] = (-1) + 0 + 1 = 0`. `nums[1] + nums[2] + nums[4] = 0 + 1 + (-1) = 0`. `nums[0] + nums[3] + nums[4] = (-1) + 2 + (-1) = 0`. The distinct triplets are `[-1,0,1]` and `[-1,-1,2]`. Notice that the order of the output and the order of the triplets does not matter.
+
+### Example 2:
+- Input: `nums = [0,1,1]`
+- Output: `[]`
+- Explanation: The only possible triplet does not sum up to `0`.
+
+### Example 3:
+- Input: `nums = [0,0,0]`
+- Output: `[[0,0,0]]`
+- Explanation: The only possible triplet sums up to `0`.
+
+### Constraints:
+
+- `3 <= nums.length <= 3000`
+- `-10^5 <= nums[i] <= 10^5`
+
+## Solution
+
+```js
+/**
+ * @param {number[]} nums
+ * @return {number[][]}
+ */
+var threeSum = function(nums) {
+    
+};
+```

docs/reference/04-trapping-rain-water.mdx

@@ -0,0 +1,35 @@
+---
+title: '42. Trapping Rain Water'
+description: 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
+sidebar:
+  badge: 'Hard'
+---
+
+<Badge variant="accent">Two Pointers</Badge>
+
+### 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.
+
+### Example 2:
+- Input: `height = [4,2,0,3,2,5]`
+- Output: `9`
+
+### Constraints:
+
+- `n == height.length`
+- `1 <= n <= 2 * 10^4`
+- `0 <= height[i] <= 10^5`
+
+## Solution
+
+```js
+/**
+ * @param {number[]} height
+ * @return {number}
+ */
+var trap = function(height) {
+    
+};
+```

docs/reference/05-group-anagrams.mdx

@@ -0,0 +1,50 @@
+---
+title: '49. Group Anagrams'
+description: Given an array of strings strs, group the anagrams together. You can return the answer in any order
+sidebar:
+  badge: 'Medium'
+---
+
+<Badge variant="accent">Hash Table</Badge>
+
+### Example 1:
+- Input: `strs = ["eat","tea","tan","ate","nat","bat"]`
+- Output: `[["bat"],["nat","tan"],["ate","eat","tea"]]`
+- Explanation: There is no string in `strs` that can be rearranged to form `"bat"`. The strings `"nat"` and `"tan"` are anagrams as they can be rearranged to form each other. The strings `"ate"`, `"eat"`, and `"tea"` are anagrams as they can be rearranged to form each other.
+
+### Example 2:
+- Input: `strs = [""]`
+- Output: `[[""]]`
+
+### Example 3:
+- Input: `strs = ["a"]`
+- Output: `[["a"]]`
+
+### Constraints:
+
+- `1 <= strs.length <= 10^4`
+- `0 <= strs[i].length <= 100`
+- `strs[i]` consists of lowercase English letters.
+
+## Solution
+
+```js
+/**
+ * @param {string[]} strs
+ * @return {string[][]}
+ */
+var groupAnagrams = function(strs) {
+  let sorted = strs.map(str => str.split("").sort().join(""));
+  let anagrams = {};
+
+  for (let i = 0; i < strs.length; i++){
+    if(!anagrams[sorted[i]]){
+      anagrams[sorted[i]] = [strs[i]]
+    }else{
+      anagrams[sorted[i]].push(strs[i])
+    }
+  }
+
+  return Object.values(anagrams);
+};
+```

docs/reference/06-valid-palindrome.mdx

@@ -0,0 +1,50 @@
+---
+title: '125. Valid Palindrome'
+description: A phrase is a palindrome if, after converting all uppercase letters into lowercase letters and removing all non-alphanumeric characters, it reads the same forward and backward. Alphanumeric characters include letters and numbers
+sidebar:
+  badge: 'Easy'
+---
+
+<Badge variant="accent">Two Pointers</Badge>
+
+### Example 1:
+- Input: `s = "A man, a plan, a canal: Panama"`
+- Output: `true`
+- Explanation: `"amanaplanacanalpanama"` is a palindrome.
+
+### Example 2:
+- Input: `s = "race a car"`
+- Output: `false`
+- Explanation: `"raceacar"` is not a palindrome.
+
+### Example 3:
+- Input: `s = " "`
+- Output: `true`
+- Explanation: `s` is an empty string `""` after removing non-alphanumeric characters. Since an empty string reads the same forward and backward, it is a palindrome.
+
+### Constraints:
+
+- `1 <= s.length <= 2 * 10^5`
+- `s` consists only of printable ASCII characters.
+
+## Solution
+
+```js
+/**
+ * @param {string} s
+ * @return {boolean}
+ */
+var isPalindrome = function(s) {
+  let normal = s.replace(/[^a-zA-Z0-9]/g, "").toLowerCase()    
+  let i = 0, j = normal.length - 1;
+
+  while (i < j) {
+    if(normal[i] !== normal[j]) {
+      return false;
+    }
+    i++;
+    j--;
+  }
+  return true;
+};
+```

docs/reference/07-two-sum-ii-input-array-is-sorted.mdx

@@ -0,0 +1,62 @@
+---
+title: '167. Two Sum II - Input Array Is Sorted'
+description: Given a 1-indexed array of integers numbers that is already sorted in non-decreasing order, find two numbers such that they add up to a specific target number. Let these two numbers be numbers[index1] and numbers[index2] where 1 <= index1 < index2 <= numbers.length
+sidebar:
+  badge: 'Medium'
+---
+
+<Badge variant="accent">Two Pointers</Badge>
+
+::::warning
+Your solution must use only constant extra space.
+::::
+
+### Example 1:
+- Input: `numbers = [2,7,11,15], target = 9`
+- Output: `[1,2]`
+- Explanation: The sum of `2` and `7` is `9`. Therefore, `index1 = 1`, `index2 = 2`. We return `[1, 2]`.
+
+### Example 2:
+- Input: `numbers = [2,3,4], target = 6`
+- Output: `[1,3]`
+- Explanation: The sum of `2` and `4` is `6`. Therefore `index1 = 1`, `index2 = 3`. We return `[1, 3]`.
+
+### Example 3:
+- Input: `numbers = [-1,0], target = -1`
+- Output: `[1,2]`
+- Explanation: The sum of `-1` and `0` is `-1`. Therefore `index1 = 1`, `index2 = 2`. We return `[1, 2]`.
+
+### Constraints:
+
+- `2 <= numbers.length <= 3 * 10^4`
+- `-1000 <= numbers[i] <= 1000`
+- `numbers` is sorted in non-decreasing order.
+- `-1000 <= target <= 1000`
+- The tests are generated such that there is exactly one solution.
+
+## Solution
+
+```js
+/**
+ * @param {number[]} numbers
+ * @param {number} target
+ * @return {number[]}
+ */
+var twoSum = function(numbers, target) {
+    let i = 0, j = numbers.length - 1;
+
+    while (i < j) {
+        const curr = numbers[i] + numbers[j];
+        if (curr === target){
+            return [i + 1, j + 1];
+        }else{
+            if (curr < target){
+                i++;
+            }else{
+                j--;
+            }
+        }
+    }
+    return [];
+};
+```

docs/reference/08-rotate-array.mdx

@@ -0,0 +1,41 @@
+---
+title: '189. Rotate Array'
+description: Given an integer array nums, rotate the array to the right by k steps, where k is non-negative
+sidebar:
+  badge: 'Medium'
+---
+
+<Badge variant="accent">Two Pointers</Badge>
+
+::::warning
+Try to come up with as many solutions as you can. There are at least three different ways to solve this problem. Could you do it in-place with `O(1)` extra space?
+::::
+
+### Example 1:
+- Input: `nums = [1,2,3,4,5,6,7], k = 3`
+- Output: `[5,6,7,1,2,3,4]`
+- Explanation: rotate 1 steps to the right: `[7,1,2,3,4,5,6]` rotate 2 steps to the right: `[6,7,1,2,3,4,5]` rotate 3 steps to the right: `[5,6,7,1,2,3,4]`
+
+### Example 2:
+- Input: `nums = [-1,-100,3,99], k = 2`
+- Output: `[3,99,-1,-100]`
+- Explanation: rotate 1 steps to the right: `[99,-1,-100,3]` rotate 2 steps to the right: `[3,99,-1,-100]`
+
+### Constraints:
+
+- `1 <= nums.length <= 10^5`
+- `-2^31 <= nums[i] <= 2^31 - 1`
+- `0 <= k <= 10^5`
+
+## Solution
+
+```js
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {void} Do not return anything, modify nums in-place instead.
+ */
+var rotate = function(nums, k) {
+    
+};
+```

docs/reference/09-contains-duplicate.mdx

@@ -0,0 +1,46 @@
+---
+title: '217. Contains Duplicate'
+description: Given an integer array nums, return true if any value appears at least twice in the array, and return false if every element is distinct
+sidebar:
+  badge: 'Easy'
+---
+
+<Badge variant="accent">Hash Table</Badge>
+
+### Example 1:
+- Input: `nums = [1,2,3,1]`
+- Output: `true`
+- Explanation: The element `1` occurs at the indices `0` and `3`.
+
+### Example 2:
+- Input: `nums = [1,2,3,4]`
+- Output: `false`
+- Explanation: All elements are distinct.
+
+### Example 3:
+- Input: `nums = [1,1,1,3,3,4,3,2,4,2]`
+- Output: `true`
+
+### Constraints:
+
+- `1 <= nums.length <= 10^5`
+- `-10^9 <= nums[i] <= 10^9`
+
+## Solution
+
+```js
+/**
+ * @param {number[]} nums
+ * @return {boolean}
+ */
+var containsDuplicate = function(nums) {
+  const freq = {};
+  for (let n of nums) {
+    freq[n] = (freq[n] || 0) + 1;
+    if (freq[n] >= 2) {
+      return true;
+    }
+  } 
+  return false;
+};
+```

docs/reference/10-product-of-array-except-self.mdx

@@ -0,0 +1,52 @@
+---
+title: '238. Product of Array Except Self'
+description: Given an integer array nums, return an array answer such that answer[i] is equal to the product of all the elements of nums except nums[i]
+sidebar:
+  badge: 'Medium'
+---
+
+<Badge variant="accent">Prefix Sum</Badge>
+
+::::warning
+You must write an algorithm that runs in O(n) time and without using the division operation.
+Can you solve the problem in O(1) extra space complexity? (The output array does not count as extra space for space complexity analysis.)
+::::
+
+### Example 1:
+- Input: `nums = [1,2,3,4]`
+- Output: `[24,12,8,6]`
+
+### Example 2:
+- Input: `nums = [-1,1,0,-3,3]`
+- Output: `[0,0,9,0,0]`
+
+### Constraints:
+
+- `2 <= nums.length <= 10^5`
+- `-30 <= nums[i] <= 30`
+- The input is generated such that `answer[i]` is guaranteed to fit in a 32-bit integer.
+
+## Solution
+
+```js
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+var productExceptSelf = function(nums) {
+  const n = nums.length;
+  const answer = new Array(n).fill(1);
+  const rightArr = new Array(n).fill(1);
+
+  for (let i = 1; i < n; i++) {
+    answer[i] = nums[i - 1] * answer[i - 1];
+  }
+  for (let i = n - 2; i >= 0; i--) {
+    rightArr[i] = nums[i + 1] * rightArr[i + 1];
+  }
+  for (let i = 0; i < n; i++) {
+    answer[i] *= rightArr[i];
+  }
+  return answer;
+};
+```

docs/reference/11-valid-anagram.mdx

@@ -0,0 +1,47 @@
+---
+title: '242. Valid Anagram'
+description: Given two strings s and t, return true if t is an anagram of s, and false otherwise
+sidebar:
+  badge: 'Easy'
+---
+
+<Badge variant="accent">Hash Table</Badge>
+
+::::warning
+What if the inputs contain Unicode characters? How would you adapt your solution to such a case?
+::::
+
+### Example 1:
+- Input: `s = "anagram", t = "nagaram"`
+- Output: `true`
+
+### Example 2:
+- Input: `s = "rat", t = "car"`
+- Output: `false`
+
+### Constraints:
+
+- `1 <= s.length, t.length <= 5 * 10^4`
+- `s` and `t` consist of lowercase English letters.
+
+## Solution
+
+```js
+/**
+ * @param {string} s
+ * @param {string} t
+ * @return {boolean}
+ */
+var isAnagram = function(s, t) {
+  let freq = {};
+  for (let c of s) freq[c] = (freq[c] || 0) + 1;
+  
+  for (let c of t) {
+    if(!freq[c] || freq[c] === 0){
+      return false;
+    }
+    freq[c] = freq[c] - 1;
+  }
+  return true;
+};
+```

docs/reference/12-missing-number.mdx

@@ -0,0 +1,54 @@
+---
+title: '268. Missing Number'
+description: Given an array nums containing n distinct numbers in the range [0, n], return the only number in the range that is missing from the array
+sidebar:
+  badge: 'Easy'
+---
+
+<Badge variant="accent">Array</Badge>
+
+::::warning
+Could you implement a solution using only O(1) extra space complexity and O(n) runtime complexity?
+::::
+
+### Example 1:
+- Input: `nums = [3,0,1]`
+- Output: `2`
+- Explanation: `n = 3` since there are `3` numbers, so all numbers are in the range `[0,3]`. `2` is the missing number in the range since it does not appear in `nums`.
+
+### Example 2:
+- Input: `nums = [0,1]`
+- Output: `2`
+- Explanation: `n = 2` since there are `2` numbers, so all numbers are in the range `[0,2]`. `2` is the missing number in the range since it does not appear in `nums`.
+
+### Example 3:
+- Input: `nums = [9,6,4,2,3,5,7,0,1]`
+- Output: `8`
+- Explanation: `n = 9` since there are `9` numbers, so all numbers are in the range `[0,9]`. `8` is the missing number in the range since it does not appear in `nums`.
+
+### Constraints:
+
+- `n == nums.length`
+- `1 <= n <= 10^4`
+- `0 <= nums[i] <= n`
+- All the numbers of `nums` are unique.
+
+## Solution
+
+```js
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var missingNumber = function(nums) {
+  const numSet = new Set(nums);
+  const expectedCount = nums.length + 1;
+
+  for (let i = 0; i < expectedCount; i++){
+    if(!numSet.has(i)){
+      return i;
+    }
+  }
+  return -1;
+};
+```

docs/reference/13-range-sum-query-immutable.mdx

@@ -0,0 +1,51 @@
+---
+title: '303. Range Sum Query - Immutable'
+description: Given an integer array nums, handle multiple queries of the following type
+sidebar:
+  badge: 'Easy'
+---
+
+<Badge variant="accent">Prefix Sum</Badge>
+
+### Example 1:
+- Input: `["NumArray", "sumRange", "sumRange", "sumRange"]` `[[[-2, 0, 3, -5, 2, -1]], [0, 2], [2, 5], [0, 5]]`
+- Output: `[null, 1, -1, -3]`
+- Explanation: `NumArray numArray = new NumArray([-2, 0, 3, -5, 2, -1]);` `numArray.sumRange(0, 2); // return (-2) + 0 + 3 = 1` `numArray.sumRange(2, 5); // return 3 + (-5) + 2 + (-1) = -1` `numArray.sumRange(0, 5); // return (-2) + 0 + 3 + (-5) + 2 + (-1) = -3`
+
+### Constraints:
+
+- `1 <= nums.length <= 10^4`
+- `-10^5 <= nums[i] <= 10^5`
+- `0 <= left <= right < nums.length`
+- At most `10^4` calls will be made to `sumRange`.
+
+## Solution
+
+```js
+/**
+ * @param {number[]} nums
+ */
+class NumArray {
+    constructor(nums) {
+      this.prefix = [0];
+      for (let n of nums){
+        this.prefix.push(this.prefix[this.prefix.length - 1] + n);
+      }
+    }
+    /**
+     * @param {number} left
+     * @param {number} right
+     * @return {number}
+     */
+    sumRange(left, right) {
+        return this.prefix[right + 1] - this.prefix[left];
+    }
+}
+
+
+/** 
+ * Your NumArray object will be instantiated and called as such:
+ * var obj = new NumArray(nums)
+ * var param_1 = obj.sumRange(left,right)
+ */
+```

docs/reference/14-top-k-frequent-elements.mdx

@@ -0,0 +1,50 @@
+---
+title: '347. Top K Frequent Elements'
+description: Given an integer array nums and an integer k, return the k most frequent elements. You may return the answer in any order
+sidebar:
+  badge: 'Medium'
+---
+
+<Badge variant="accent">Hash Table</Badge>
+
+::::warning
+Your algorithm's time complexity must be better than O(n log n), where n is the array's size.
+::::
+
+### Example 1:
+- Input: `nums = [1,1,1,2,2,3], k = 2`
+- Output: `[1,2]`
+
+### Example 2:
+- Input: `nums = [1], k = 1`
+- Output: `[1]`
+
+### Example 3:
+- Input: `nums = [1,2,1,2,1,2,3,1,3,2], k = 2`
+- Output: `[1,2]`
+
+### Constraints:
+
+- `1 <= nums.length <= 10^5`
+- `-10^4 <= nums[i] <= 10^4`
+- `k` is in the range `[1, the number of unique elements in the array]`.
+- It is guaranteed that the answer is unique.
+
+## Solution
+
+```js
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number[]}
+ */
+var topKFrequent = function (nums, k) {
+  const freq = {};
+  for (let n of nums) freq[n] = (freq[n] || 0) + 1;
+
+  return Object.keys(freq)
+    .map(Number)
+    .sort((a, b) => freq[b] - freq[a])
+    .slice(0, k);
+};
+```

docs/reference/15-first-unique-character-in-a-string.mdx

@@ -0,0 +1,46 @@
+---
+title: '387. First Unique Character in a String'
+description: Given a string s, find the first non-repeating character in it and return its index. If it does not exist, return -1
+sidebar:
+  badge: 'Easy'
+---
+
+<Badge variant="accent">Hash Table</Badge>
+
+### Example 1:
+- Input: `s = "leetcode"`
+- Output: `0`
+- Explanation: The character `'l'` at index `0` is the first character that does not occur at any other index.
+
+### Example 2:
+- Input: `s = "loveleetcode"`
+- Output: `2`
+
+### Example 3:
+- Input: `s = "aabb"`
+- Output: `-1`
+
+### Constraints:
+
+- `1 <= s.length <= 10^5`
+- `s` consists of only lowercase English letters.
+
+## Solution
+
+```js
+/**
+ * @param {string} s
+ * @return {number}
+ */
+var firstUniqChar = function (s) {
+  const freq = {};
+  for (let c of s) freq[c] = (freq[c] || 0) + 1;
+
+  for (let i = 0; i < s.length; i++) {
+    if (freq[s[i]] === 1) {
+      return i;
+    }
+  }
+  return -1;
+};
+```

docs/reference/16-sort-characters-by-frequency.mdx

@@ -0,0 +1,48 @@
+---
+title: '451. Sort Characters By Frequency'
+description: Given a string s, sort it in decreasing order based on the frequency of the characters. The frequency of a character is the number of times it appears in the string
+sidebar:
+  badge: 'Medium'
+---
+
+<Badge variant="accent">Hash Table</Badge>
+
+### Example 1:
+- Input: `s = "tree"`
+- Output: `"eert"`
+- Explanation: `'e'` appears twice while `'r'` and `'t'` both appear once. So `'e'` must appear before both `'r'` and `'t'`. Therefore `"eetr"` is also a valid answer.
+
+### Example 2:
+- Input: `s = "cccaaa"`
+- Output: `"aaaccc"`
+- Explanation: Both `'c'` and `'a'` appear three times, so both `"cccaaa"` and `"aaaccc"` are valid answers. Note that `"cacaca"` is incorrect, as the same characters must be together.
+
+### Example 3:
+- Input: `s = "Aabb"`
+- Output: `"bbAa"`
+- Explanation: `"bbaA"` is also a valid answer, but `"Aabb"` is incorrect. Note that `'A'` and `'a'` are treated as two different characters.
+
+### Constraints:
+
+- `1 <= s.length <= 5 * 10^5`
+- `s` consists of uppercase and lowercase English letters and digits.
+
+## Solution
+
+```js
+/**
+ * @param {string} s
+ * @return {string}
+ */
+var frequencySort = function (s) {
+  // count the frequency of each character
+  const freq = {};
+  for (let c of s) freq[c] = (freq[c] || 0) + 1;
+
+  // sort the characters by frequency
+  return s
+    .split("")
+    .sort((a, b) => freq[b] - freq[a] || a.localeCompare(b))
+    .join("");
+};
+```

docs/reference/17-subarray-sum-equals-k.mdx

@@ -0,0 +1,50 @@
+---
+title: '560. Subarray Sum Equals K'
+description: Given an array of integers nums and an integer k, return the total number of subarrays whose sum equals to k
+sidebar:
+  badge: 'Medium'
+---
+
+<Badge variant="accent">Prefix Sum</Badge>
+
+### Example 1:
+- Input: `nums = [1,1,1], k = 2`
+- Output: `2`
+
+### Example 2:
+- Input: `nums = [1,2,3], k = 3`
+- Output: `2`
+
+### Constraints:
+
+- `1 <= nums.length <= 2 * 10^4`
+- `-1000 <= nums[i] <= 1000`
+- `-10^7 <= k <= 10^7`
+
+## Solution
+
+```js
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+var subarraySum = function(nums, k) {
+  const map = new Map();
+  map.set(0, 1);
+
+  let sum = 0;
+  let count = 0;
+
+  for (let n of nums){
+    sum += n;
+
+    if(map.has(sum - k)){
+      count += map.get(sum - k);
+    }
+
+    map.set(sum, (map.get(sum) || 0) + 1);
+  }
+  return count
+};
+```

docs/reference/18-how-many-numbers-are-smaller-than-the-current-number.mdx

@@ -0,0 +1,62 @@
+---
+title: '1365. How Many Numbers Are Smaller Than the Current Number'
+description: Given the array nums, for each nums[i] find out how many numbers in the array are smaller than it. That is, for each nums[i] you have to count the number of valid j's such that j != i and nums[j] < nums[i]
+sidebar:
+  badge: 'Easy'
+---
+
+<Badge variant="accent">Array</Badge>
+
+### Example 1:
+- Input: `nums = [8,1,2,2,3]`
+- Output: `[4,0,1,1,3]`
+- Explanation: For `nums[0]=8` there exist four smaller numbers than it (`1`, `2`, `2` and `3`). For `nums[1]=1` does not exist any smaller number than it. For `nums[2]=2` there exist one smaller number than it (`1`). For `nums[3]=2` there exist one smaller number than it (`1`). For `nums[4]=3` there exist three smaller numbers than it (`1`, `2` and `2`).
+
+### Example 2:
+- Input: `nums = [6,5,4,8]`
+- Output: `[2,1,0,3]`
+
+### Example 3:
+- Input: `nums = [7,7,7,7]`
+- Output: `[0,0,0,0]`
+
+### Constraints:
+
+- `2 <= nums.length <= 500`
+- `0 <= nums[i] <= 100`
+
+## Solution
+
+```js
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+
+var smallerNumbersThanCurrent = function (nums) {
+  // Step 1: Begin by initializing a [Frequency Map]()
+  const freq = {};
+  for (let n of nums) freq[n] = (freq[n] || 0) + 1;
+
+  // Step 2: Sort the numbers by ascending order
+  const sorted = Object.keys(freq).sort((a, b) => a - b);
+
+  // Step 3: Init a count of numbers smaller than the active number
+  let count = 0;
+
+  // Step 4: Init a map to track number of values smaller for each number
+  const smaller = {};
+
+  // Step 5: Iterate over the sorted list
+  for (let num of sorted) {
+    // Set count for active number
+    smaller[num] = count;
+
+    // Update the count by frequency
+    count += freq[num];
+  }
+
+  // Step 6: Use original list and find number of smaller values than it
+  return nums.map((n) => smaller[n]);
+};
+```

docs/reference/19-minimum-value-to-get-positive-step-by-step-sum.mdx

@@ -0,0 +1,56 @@
+---
+title: '1413. Minimum Value to Get Positive Step by Step Sum'
+description: Given an array of integers nums, you start with an initial positive value startValue
+sidebar:
+  badge: 'Easy'
+---
+
+<Badge variant="accent">Array</Badge>
+
+### Example 1:
+- Input: `nums = [-3,2,-3,4,2]`
+- Output: `5`
+- Explanation: If you choose `startValue = 4`, in the third iteration your step by step sum is less than `1`.
+
+```
+step by step sum
+startValue = 4 | startValue = 5 | nums
+  (4 -3 ) = 1  | (5 -3 ) = 2    |  -3
+  (1 +2 ) = 3  | (2 +2 ) = 4    |   2
+  (3 -3 ) = 0  | (4 -3 ) = 1    |  -3
+  (0 +4 ) = 4  | (1 +4 ) = 5    |   4
+  (4 +2 ) = 6  | (5 +2 ) = 7    |   2
+```
+
+### Example 2:
+- Input: `nums = [1,2]`
+- Output: `1`
+- Explanation: Minimum start value should be positive.
+
+### Example 3:
+- Input: `nums = [1,-2,-3]`
+- Output: `5`
+
+### Constraints:
+
+- `1 <= nums.length <= 100`
+- `-100 <= nums[i] <= 100`
+
+## Solution
+
+```js
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var minStartValue = function(nums) {
+  let prefix = [nums[0]];
+  // Make prefix sum start at 1 after initializing seed value
+  for (let i = 1; i < nums.length; i++){
+    prefix.push(prefix[i - 1] + nums[i]);
+  }
+
+  let min = Math.min(...prefix);
+  return Math.max(1, 1 - min);
+};
+```

docs/reference/20-counting-elements.mdx

@@ -0,0 +1,44 @@
+---
+title: '1426. Counting Elements'
+description: Given an integer array arr, count how many elements x there are, such that x + 1 is also in arr. If there are duplicates in arr, count them separately
+sidebar:
+  badge: 'Easy'
+---
+
+<Badge variant="accent">Array</Badge>
+
+### Example 1:
+- Input: `arr = [1,2,3]`
+- Output: `2`
+- Explanation: `1` and `2` are counted cause `2` and `3` are in `arr`.
+
+### Example 2:
+- Input: `arr = [1,1,3,3,5,5,7,7]`
+- Output: `0`
+- Explanation: No numbers are counted, cause there is no `2`, `4`, `6`, or `8` in `arr`.
+
+### Constraints:
+
+- `1 <= arr.length <= 1000`
+- `0 <= arr[i] <= 1000`
+
+## Solution
+
+```js
+/**
+ * @param {number[]} arr
+ * @return {number}
+ */
+var countElements = function(arr) {
+  let arrSet = new Set(arr);
+  let count = 0; 
+
+  for (let n of arr) {
+    let sum = n + 1;
+    if (arrSet.has(sum)) {
+      count++;
+    }
+  }
+  return count;
+};
+```

docs/reference/21-running-sum-of-1d-array.mdx

@@ -0,0 +1,43 @@
+---
+title: '1480. Running Sum of 1d Array'
+description: Given an array nums. We define a running sum of an array as runningSum[i] = sum(nums[0]…nums[i])
+sidebar:
+  badge: 'Easy'
+---
+
+<Badge variant="accent">Array</Badge>
+
+### Example 1:
+- Input: `nums = [1,2,3,4]`
+- Output: `[1,3,6,10]`
+- Explanation: Running sum is obtained as follows: `[1, 1+2, 1+2+3, 1+2+3+4]`.
+
+### Example 2:
+- Input: `nums = [1,1,1,1,1]`
+- Output: `[1,2,3,4,5]`
+- Explanation: Running sum is obtained as follows: `[1, 1+1, 1+1+1, 1+1+1+1, 1+1+1+1+1]`.
+
+### Example 3:
+- Input: `nums = [3,1,2,10,1]`
+- Output: `[3,4,6,16,17]`
+
+### Constraints:
+
+- `1 <= nums.length <= 1000`
+- `-10^6 <= nums[i] <= 10^6`
+
+## Solution
+
+```js
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+var runningSum = function(nums) {
+  let prefix = [nums[0]];
+  for (let i = 1; i < nums.length; i++){
+    prefix.push(prefix[i - 1] + nums[i]);
+  }
+  return prefix;
+};
+```

docs/reference/22-sort-array-by-increasing-frequency.mdx

@@ -0,0 +1,41 @@
+---
+title: '1636. Sort Array by Increasing Frequency'
+description: Given an array of integers nums, sort the array in increasing order based on the frequency of the values. If multiple values have the same frequency, sort them in decreasing order
+sidebar:
+  badge: 'Easy'
+---
+
+<Badge variant="accent">Array</Badge>
+
+### Example 1:
+- Input: `nums = [1,1,2,2,2,3]`
+- Output: `[3,1,1,2,2,2]`
+- Explanation: `'3'` has a frequency of `1`, `'1'` has a frequency of `2`, and `'2'` has a frequency of `3`.
+
+### Example 2:
+- Input: `nums = [2,3,1,3,2]`
+- Output: `[1,3,3,2,2]`
+- Explanation: `'2'` and `'3'` both have a frequency of `2`, so they are sorted in decreasing order.
+
+### Example 3:
+- Input: `nums = [-1,1,-6,4,5,-6,1,4,1]`
+- Output: `[5,-1,4,4,-6,-6,1,1,1]`
+
+### Constraints:
+
+- `1 <= nums.length <= 100`
+- `-100 <= nums[i] <= 100`
+
+## Solution
+
+```js
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+var frequencySort = function (nums) {
+  const freq = {};
+  for (let n of nums) freq[n] = (freq[n] || 0) + 1;
+  return nums.sort((a, b) => freq[a] - freq[b] || b - a);
+};
+```

docs/reference/23-check-if-the-sentence-is-pangram.mdx

@@ -0,0 +1,40 @@
+---
+title: '1832. Check if the Sentence Is Pangram'
+description: A pangram is a sentence where every letter of the English alphabet appears at least once
+sidebar:
+  badge: 'Easy'
+---
+
+<Badge variant="accent">Hash Table</Badge>
+
+### Example 1:
+- Input: `sentence = "thequickbrownfoxjumpsoverthelazydog"`
+- Output: `true`
+- Explanation: `sentence` contains at least one of every letter of the English alphabet.
+
+### Example 2:
+- Input: `sentence = "leetcode"`
+- Output: `false`
+
+### Constraints:
+
+- `1 <= sentence.length <= 1000`
+- `sentence` consists of lowercase English letters.
+
+## Solution
+
+```js
+/**
+ * @param {string} sentence
+ * @return {boolean}
+ */
+var checkIfPangram = function(sentence) {
+    const freq = {};
+    for (let c of sentence) freq[c] = (freq[c] || 0) + 1;
+    
+    if (Object.keys(freq).length === 26){
+        return true;
+    }
+    return false;
+};
+```

docs/reference/24-k-radius-subarray-averages.mdx

@@ -0,0 +1,49 @@
+---
+title: '2090. K Radius Subarray Averages'
+description: You are given a 0-indexed array nums of n integers, and an integer k
+sidebar:
+  badge: 'Medium'
+---
+
+<Badge variant="accent">Array</Badge>
+
+### Example 1:
+- Input: `nums = [7,4,3,9,1,8,5,2,6], k = 3`
+- Output: `[-1,-1,-1,5,4,4,-1,-1,-1]`
+- Explanation:
+  - `avg[0]`, `avg[1]`, and `avg[2]` are `-1` because there are less than `k` elements before each index.
+  - The sum of the subarray centered at index `3` with radius `3` is: `7 + 4 + 3 + 9 + 1 + 8 + 5 = 37`. Using integer division, `avg[3] = 37 / 7 = 5`.
+  - For the subarray centered at index `4`, `avg[4] = (4 + 3 + 9 + 1 + 8 + 5 + 2) / 7 = 4`.
+  - For the subarray centered at index `5`, `avg[5] = (3 + 9 + 1 + 8 + 5 + 2 + 6) / 7 = 4`.
+  - `avg[6]`, `avg[7]`, and `avg[8]` are `-1` because there are less than `k` elements after each index.
+
+### Example 2:
+- Input: `nums = [100000], k = 0`
+- Output: `[100000]`
+- Explanation:
+  - The sum of the subarray centered at index `0` with radius `0` is: `100000`. `avg[0] = 100000 / 1 = 100000`.
+
+### Example 3:
+- Input: `nums = [8], k = 100000`
+- Output: `[-1]`
+- Explanation:
+  - `avg[0]` is `-1` because there are less than `k` elements before and after index `0`.
+
+### Constraints:
+
+- `n == nums.length`
+- `1 <= n <= 10^5`
+- `0 <= nums[i], k <= 10^5`
+
+## Solution
+
+```js
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number[]}
+ */
+var getAverages = function(nums, k) {
+    
+};
+```