docs(hash-table): add first unique character in a string LC-387

docs(array): add sort array by increasing frequency LC-1636
docs(array): add top k frequent elements LC-347
docs(hash-table): add sort characters by frequency LC-451
docs(array): add minor edit to how many numbers are smaller than current LC-1365

docs/content/docs/array/1365.mdx

@@ -16,8 +16,8 @@ description: How Many Numbers Are Smaller Than the Current Number
 <Accordions type="single">
   <Accordion title="Constraints">
     Constraints:
-     - 2 <= `nums.length` <= 500
-     - 0 <= `nums[i]` <= 100
+     • `2 <= nums.length <= 500`
+     • `0 <= nums[i] <= 100`
   </Accordion>
   <Accordion title="Problem Statement">
     Given the array nums, for each `nums[i]` find out how many numbers in the array are smaller than it. 
@@ -32,6 +32,7 @@ description: How Many Numbers Are Smaller Than the Current Number
  * @param {number[]} nums
  * @return {number[]}
  */
+
 var smallerNumbersThanCurrent = function (nums) {
   // Default for Hammer
   const freq = {};

docs/content/docs/array/1636.mdx

@@ -0,0 +1,46 @@
+---
+title: LC-1636
+description: Sort Array by Increasing Frequency
+---
+
+## Examples
+
+| Input                  | Output                 |
+| ---------------------- | ---------------------- |
+| `[1,1,2,2,2,3]`        | `[3,1,1,2,2,2]`        |
+| `[2,3,1,3,2]`          | `[1,3,3,2,2]`          |
+| `[-1,1,-6,4,5,-6,1,4,1]` | `[5,-1,4,4,-6,-6,1,1,1]` |
+
+## Hints
+
+<Accordions type="single">
+  <Accordion title="Constraints">
+    Constraints:
+     • `1 <= nums.length <= 100`
+     • `-100 <= nums[i] <= 100`
+  </Accordion>
+  <Accordion title="Problem Statement">
+    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.
+    Return the sorted array.
+  </Accordion>
+</Accordions>
+
+## Solution
+
+```js
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+
+var frequencySort = function (nums) {
+  // Default for Hammer
+  const freq = {};
+  for (let n of nums) freq[n] = (freq[n] || 0) + 1;
+
+  // Problem Specific
+  // Sort ascending by frequency; ties break by larger value first
+  return nums.sort((a, b) => freq[a] - freq[b] || b - a);
+};
+```

docs/content/docs/array/347.mdx

@@ -0,0 +1,53 @@
+---
+title: LC-347
+description: Top K Frequent Elements
+---
+
+## Examples
+
+| Input                              | Output   |
+| ---------------------------------- | -------- |
+| `nums = [1,1,1,2,2,3], k = 2`      | `[1,2]`  |
+| `nums = [1], k = 1`                | `[1]`    |
+| `nums = [1,2,1,2,1,2,3,1,3,2], k = 2` | `[1,2]` |
+
+## Hints
+
+<Accordions type="single">
+  <Accordion title="Constraints">
+    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.
+  </Accordion>
+  <Accordion title="Problem Statement">
+    Given an integer array nums and an integer `k`, return the `k` most frequent elements.
+    You may return the answer in any order.
+
+    Follow up: Your algorithm's time complexity must be better than `O(n log n)`, where n is the array's size.
+  </Accordion>
+</Accordions>
+
+## Solution
+
+```js
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number[]}
+ */
+
+var topKFrequent = function (nums, k) {
+  // Default for Hammer
+  const freq = {};
+  for (let n of nums) freq[n] = (freq[n] || 0) + 1;
+
+  // Problem Specific
+  // Sort unique values by descending frequency, take the first k
+  return Object.keys(freq)
+    .map(Number)
+    .sort((a, b) => freq[b] - freq[a])
+    .slice(0, k);
+};
+```

docs/content/docs/hash-table/387.mdx

@@ -0,0 +1,50 @@
+---
+title: LC-387
+description: First Unique Character in a String
+---
+
+## Examples
+
+| Input            | Output |
+| ---------------- | ------ |
+| `"leetcode"`     | `0`    |
+| `"loveleetcode"` | `2`    |
+| `"aabb"`         | `-1`   |
+
+## Hints
+
+<Accordions type="single">
+  <Accordion title="Constraints">
+    Constraints:
+     • `1 <= s.length <= 10^5`
+     • `s` consists of only lowercase English letters.
+  </Accordion>
+  <Accordion title="Problem Statement">
+    Given a string `s`, find the first non-repeating character in it and return its index.
+    If it does not exist, return `-1`.
+  </Accordion>
+</Accordions>
+
+## Solution
+
+```js
+/**
+ * @param {string} s
+ * @return {number}
+ */
+
+var firstUniqChar = function (s) {
+  // Default for Hammer
+  const freq = {};
+  for (let c of s) freq[c] = (freq[c] || 0) + 1;
+
+  // Problem Specific
+  // Loop the ORIGINAL string — we want an index, so no sorting
+  for (let i = 0; i < s.length; i++) {
+    if (freq[s[i]] === 1) {
+      return i;
+    }
+  }
+  return -1;
+};
+```

docs/content/docs/hash-table/451.mdx

@@ -0,0 +1,49 @@
+---
+title: LC-451
+description: Sort Characters By Frequency
+---
+
+## Examples
+
+| Input      | Output   |
+| ---------- | -------- |
+| `"tree"`   | `"eert"` |
+| `"cccaaa"` | `"aaaccc"` |
+| `"Aabb"`   | `"bbAa"` |
+
+## Hints
+
+<Accordions type="single">
+  <Accordion title="Constraints">
+    Constraints:
+     • `1 <= s.length <= 5 * 10^5`
+     • `s` consists of uppercase and lowercase English letters and digits.
+  </Accordion>
+  <Accordion title="Problem Statement">
+    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.
+    Return the sorted string. If there are multiple answers, return any of them.
+  </Accordion>
+</Accordions>
+
+## Solution
+
+```js
+/**
+ * @param {string} s
+ * @return {string}
+ */
+
+var frequencySort = function (s) {
+  // Default for Hammer
+  const freq = {};
+  for (let c of s) freq[c] = (freq[c] || 0) + 1;
+
+  // Problem Specific
+  // Sort characters by descending frequency; same chars stay grouped
+  return s
+    .split("")
+    .sort((a, b) => freq[b] - freq[a] || a.localeCompare(b))
+    .join("");
+};
+```