From 1eda2521013c254417651085b76f75ddbf0807b9 Mon Sep 17 00:00:00 2001 From: Prad Nukala Date: Sun, 12 Jul 2026 20:56:17 -0400 Subject: [PATCH] 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 | 5 +-- docs/content/docs/array/1636.mdx | 46 ++++++++++++++++++++++++ docs/content/docs/array/347.mdx | 53 ++++++++++++++++++++++++++++ docs/content/docs/hash-table/387.mdx | 50 ++++++++++++++++++++++++++ docs/content/docs/hash-table/451.mdx | 49 +++++++++++++++++++++++++ 5 files changed, 201 insertions(+), 2 deletions(-) create mode 100644 docs/content/docs/array/1636.mdx create mode 100644 docs/content/docs/array/347.mdx create mode 100644 docs/content/docs/hash-table/387.mdx create mode 100644 docs/content/docs/hash-table/451.mdx diff --git a/docs/content/docs/array/1365.mdx b/docs/content/docs/array/1365.mdx index 682f920..83b2df3 100644 --- a/docs/content/docs/array/1365.mdx +++ b/docs/content/docs/array/1365.mdx @@ -16,8 +16,8 @@ description: How Many Numbers Are Smaller Than the Current Number Constraints: - - 2 <= `nums.length` <= 500 - - 0 <= `nums[i]` <= 100 + • `2 <= nums.length <= 500` + • `0 <= nums[i] <= 100` 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 = {}; diff --git a/docs/content/docs/array/1636.mdx b/docs/content/docs/array/1636.mdx new file mode 100644 index 0000000..d829a6b --- /dev/null +++ b/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 + + + + Constraints: + • `1 <= nums.length <= 100` + • `-100 <= nums[i] <= 100` + + + 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. + + + +## 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); +}; +``` diff --git a/docs/content/docs/array/347.mdx b/docs/content/docs/array/347.mdx new file mode 100644 index 0000000..98b69de --- /dev/null +++ b/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 + + + + 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. + + + 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. + + + +## 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); +}; +``` diff --git a/docs/content/docs/hash-table/387.mdx b/docs/content/docs/hash-table/387.mdx new file mode 100644 index 0000000..bef582a --- /dev/null +++ b/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 + + + + Constraints: + • `1 <= s.length <= 10^5` + • `s` consists of only lowercase English letters. + + + Given a string `s`, find the first non-repeating character in it and return its index. + If it does not exist, return `-1`. + + + +## 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; +}; +``` diff --git a/docs/content/docs/hash-table/451.mdx b/docs/content/docs/hash-table/451.mdx new file mode 100644 index 0000000..bd8fcaf --- /dev/null +++ b/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 + + + + Constraints: + • `1 <= s.length <= 5 * 10^5` + • `s` consists of uppercase and lowercase English letters and digits. + + + 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. + + + +## 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(""); +}; +```