docs: add sidebar labels and reorganize solution docs into category folders

docs/solutions/(hash-table)/1832-check-if-the-sentence-is-pangram.mdx

@@ -0,0 +1,41 @@
+---
+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:
+  label: 'Check if the Sentence Is Pangram'
+  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/solutions/(hash-table)/242-valid-anagram.mdx

@@ -0,0 +1,48 @@
+---
+title: '242. Valid Anagram'
+description: Given two strings s and t, return true if t is an anagram of s, and false otherwise
+sidebar:
+  label: 'Valid Anagram'
+  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/solutions/(hash-table)/387-first-unique-character-in-a-string.mdx

@@ -0,0 +1,47 @@
+---
+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:
+  label: 'First Unique Character in a String'
+  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/solutions/(hash-table)/451-sort-characters-by-frequency.mdx

@@ -0,0 +1,49 @@
+---
+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:
+  label: 'Sort Characters By Frequency'
+  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("");
+};
+```