diff --git a/docs/reference/01-reverse-string.mdx b/docs/reference/01-reverse-string.mdx
index fe6b466..9b13591 100644
--- a/docs/reference/01-reverse-string.mdx
+++ b/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;
diff --git a/docs/reference/03-3sum.mdx b/docs/reference/03-3sum.mdx
new file mode 100644
index 0000000..3961664
--- /dev/null
+++ b/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'
+---
+
+Two Pointers
+
+::::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) {
+
+};
+```
diff --git a/docs/reference/04-trapping-rain-water.mdx b/docs/reference/04-trapping-rain-water.mdx
new file mode 100644
index 0000000..d3397fb
--- /dev/null
+++ b/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'
+---
+
+Two Pointers
+
+### 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) {
+
+};
+```
diff --git a/docs/reference/05-group-anagrams.mdx b/docs/reference/05-group-anagrams.mdx
new file mode 100644
index 0000000..e1be071
--- /dev/null
+++ b/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'
+---
+
+Hash Table
+
+### 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);
+};
+```
diff --git a/docs/reference/06-valid-palindrome.mdx b/docs/reference/06-valid-palindrome.mdx
new file mode 100644
index 0000000..0733180
--- /dev/null
+++ b/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'
+---
+
+Two Pointers
+
+### 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;
+};
+```
diff --git a/docs/reference/07-two-sum-ii-input-array-is-sorted.mdx b/docs/reference/07-two-sum-ii-input-array-is-sorted.mdx
new file mode 100644
index 0000000..cec8b15
--- /dev/null
+++ b/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'
+---
+
+Two Pointers
+
+::::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 [];
+};
+```
diff --git a/docs/reference/08-rotate-array.mdx b/docs/reference/08-rotate-array.mdx
new file mode 100644
index 0000000..6702d86
--- /dev/null
+++ b/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'
+---
+
+Two Pointers
+
+::::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) {
+
+};
+```
diff --git a/docs/reference/09-contains-duplicate.mdx b/docs/reference/09-contains-duplicate.mdx
new file mode 100644
index 0000000..883e8cd
--- /dev/null
+++ b/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'
+---
+
+Hash Table
+
+### 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;
+};
+```
diff --git a/docs/reference/10-product-of-array-except-self.mdx b/docs/reference/10-product-of-array-except-self.mdx
new file mode 100644
index 0000000..41458e1
--- /dev/null
+++ b/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'
+---
+
+Prefix Sum
+
+::::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;
+};
+```
diff --git a/docs/reference/11-valid-anagram.mdx b/docs/reference/11-valid-anagram.mdx
new file mode 100644
index 0000000..68ba1e2
--- /dev/null
+++ b/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'
+---
+
+Hash Table
+
+::::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;
+};
+```
diff --git a/docs/reference/12-missing-number.mdx b/docs/reference/12-missing-number.mdx
new file mode 100644
index 0000000..675a663
--- /dev/null
+++ b/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'
+---
+
+Array
+
+::::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;
+};
+```
diff --git a/docs/reference/13-range-sum-query-immutable.mdx b/docs/reference/13-range-sum-query-immutable.mdx
new file mode 100644
index 0000000..4df964b
--- /dev/null
+++ b/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'
+---
+
+Prefix Sum
+
+### 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)
+ */
+```
diff --git a/docs/reference/14-top-k-frequent-elements.mdx b/docs/reference/14-top-k-frequent-elements.mdx
new file mode 100644
index 0000000..630e8a6
--- /dev/null
+++ b/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'
+---
+
+Hash Table
+
+::::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);
+};
+```
diff --git a/docs/reference/15-first-unique-character-in-a-string.mdx b/docs/reference/15-first-unique-character-in-a-string.mdx
new file mode 100644
index 0000000..093edb7
--- /dev/null
+++ b/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'
+---
+
+Hash Table
+
+### 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;
+};
+```
diff --git a/docs/reference/16-sort-characters-by-frequency.mdx b/docs/reference/16-sort-characters-by-frequency.mdx
new file mode 100644
index 0000000..e77c2b5
--- /dev/null
+++ b/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'
+---
+
+Hash Table
+
+### 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("");
+};
+```
diff --git a/docs/reference/17-subarray-sum-equals-k.mdx b/docs/reference/17-subarray-sum-equals-k.mdx
new file mode 100644
index 0000000..3c8b7af
--- /dev/null
+++ b/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'
+---
+
+Prefix Sum
+
+### 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
+};
+```
diff --git a/docs/reference/18-how-many-numbers-are-smaller-than-the-current-number.mdx b/docs/reference/18-how-many-numbers-are-smaller-than-the-current-number.mdx
new file mode 100644
index 0000000..61f5e87
--- /dev/null
+++ b/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'
+---
+
+Array
+
+### 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]);
+};
+```
diff --git a/docs/reference/19-minimum-value-to-get-positive-step-by-step-sum.mdx b/docs/reference/19-minimum-value-to-get-positive-step-by-step-sum.mdx
new file mode 100644
index 0000000..2d1a9c5
--- /dev/null
+++ b/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'
+---
+
+Array
+
+### 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);
+};
+```
diff --git a/docs/reference/20-counting-elements.mdx b/docs/reference/20-counting-elements.mdx
new file mode 100644
index 0000000..1f25f31
--- /dev/null
+++ b/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'
+---
+
+Array
+
+### 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;
+};
+```
diff --git a/docs/reference/21-running-sum-of-1d-array.mdx b/docs/reference/21-running-sum-of-1d-array.mdx
new file mode 100644
index 0000000..b4872fc
--- /dev/null
+++ b/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'
+---
+
+Array
+
+### 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;
+};
+```
diff --git a/docs/reference/22-sort-array-by-increasing-frequency.mdx b/docs/reference/22-sort-array-by-increasing-frequency.mdx
new file mode 100644
index 0000000..2aa0228
--- /dev/null
+++ b/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'
+---
+
+Array
+
+### 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);
+};
+```
diff --git a/docs/reference/23-check-if-the-sentence-is-pangram.mdx b/docs/reference/23-check-if-the-sentence-is-pangram.mdx
new file mode 100644
index 0000000..62cbc6d
--- /dev/null
+++ b/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'
+---
+
+Hash Table
+
+### 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;
+};
+```
diff --git a/docs/reference/24-k-radius-subarray-averages.mdx b/docs/reference/24-k-radius-subarray-averages.mdx
new file mode 100644
index 0000000..aceecb6
--- /dev/null
+++ b/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'
+---
+
+Array
+
+### 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) {
+
+};
+```