py/leetcode
1
0 Fork 0
mirror of https://github.com/prdlk/leetcode.git synced 2026-11-02 21:22:43 +00:00
Code Issues Packages Projects Releases Wiki Activity

docs(docs): migrate to array based folder structure

Browse Source
This commit is contained in:
Prad Nukala committed 2026-07-14 11:07:15 -04:00
1 parent a7f9fc28e0
commit 172bdcf40e
24 files changed
+64 -2914
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

docs/content/docs/array/1365.mdx
-55
View File
@@ -1,55 +0,0 @@
---
title: LC-1365
description: How Many Numbers Are Smaller Than the Current Number
---
## Examples
| Input | Output |
| ---------------- | -------------------- |
| `[8,1,2,2,3]` | `[4,0,1,1,3]` |
| `[6,5,4,8]` | `[2,1,0,3]` |
| `[7,7,7,7]` | `[0,0,0,0]` |
## Hints
<Accordions type="single">
<Accordion title="Constraints">
Constraints:
• `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.
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]`.
</Accordion>
</Accordions>
## Solution
```js
/**
* @param {number[]} nums
* @return {number[]}
*/
var smallerNumbersThanCurrent = function (nums) {
// Default for Hammer
const freq = {};
for (let n of nums) freq[n] = (freq[n] || 0) + 1;
const sorted = Object.keys(freq).sort((a, b) => a - b);
// Problem Specific
let count = 0;
let smaller = {};
// Iterate over sorted.
for (let num of sorted) {
smaller[num] = count;
count += freq[num];
}
// Map output
return nums.map((n) => smaller[n]);
};
```
docs/content/docs/array/1636.mdx
-46
View File
@@ -1,46 +0,0 @@
---
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
-53
View File
@@ -1,53 +0,0 @@
---
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
-50
View File
@@ -1,50 +0,0 @@
---
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
-49
View File
@@ -1,49 +0,0 @@
---
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("");
};
```
docs/content/docs/index.mdx
-68
View File
@@ -1,68 +0,0 @@
---
title: Introduction
description: Prad's Random Leetcode Notes
---
## Overview
This is a collection of random CS notes that I've made over the years. I've been learning CS for a while now and I thought it would be a good idea to make a public repository of my notes. This is the first iteration of the repository and I plan to add more content to it over time.
## The Golden Rule (Memorize This)
**Only sort if the problem asks for ORDER or RANKING.**
If the problem asks for:
- "first"
- "index"
- "position"
- "does it exist"
- "true/false"
- "count how many"
→ **DO NOT SORT**. Just use the frequency map and loop.
---
## Decision Cheat Sheet
| What the problem wants | Do you need to sort? | What to do instead | Example Problem |
|-----------------------------------------|----------------------|-------------------------------------|---------------------|
| Sort characters by how often they appear | YES | Freq + Sort | LC 451 |
| Top K most frequent | YES | Freq + Sort + slice | LC 347 |
| Sort array by frequency | YES | Freq + Sort | LC 1636 |
| First unique character (index) | NO | Freq + loop original string | LC 387 |
| Is it an anagram? | NO | Freq + check counts | LC 242 |
| How many numbers smaller than current | Kind of | Freq + prefix count | LC 1365 |
| Most frequent element | NO | Freq + find max | LC 169 |
---
## Mental Checklist (Say this out loud every time)
1. "Did I count the frequencies?" → Yes
2. "Does the problem care about the **original order**?"
- Yes → Loop the original string/array and check freq
- No → You can sort
3. "Does it want an **index** or a **boolean**?"
- Yes → Almost never sort
4. "Does it want the elements **re-ordered**?"
- Yes → Sort by frequency
---
## Super Short Version to Tattoo in Your Brain
**"If it wants the first / index / true-false → loop original.
If it wants sorted / top k / reordered → sort."**
---
## Practice Trigger Words
- "first non-repeating" → Loop original
- "return its index" → Loop original
- "sort by frequency" → Sort
- "top k frequent" → Sort + slice
- "valid anagram" → Just check counts