docs/leetcode
1
0
Fork 0
mirror of https://github.com/prdlk/leetcode.git synced 2026-09-17 07:26:27 +00:00
Code Issues Packages Projects Releases Wiki Activity

docs(docs): delete obsolete Leetcode documentation files

Browse Source
This commit is contained in:
Prad Nukala
2026-08-13 19:38:06 -04:00
parent f4edb09e5e
commit 667ccbe1da
9 changed files with 0 additions and 342 deletions
Download Patch File Download Diff File Expand all files Collapse all files
docs/(welcome)/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
<Accordion type="single">
<AccordionItem title="Constraints">
Constraints:
• `2 <= nums.length <= 500`
• `0 <= nums[i] <= 100`
</AccordionItem>
<AccordionItem 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]`.
</AccordionItem>
</Accordion>
## 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/(welcome)/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
<Accordion type="single">
<AccordionItem title="Constraints">
Constraints:
• `1 <= nums.length <= 100`
• `-100 <= nums[i] <= 100`
</AccordionItem>
<AccordionItem 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.
</AccordionItem>
</Accordion>
## 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/(welcome)/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
<Accordion type="single">
<AccordionItem 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.
</AccordionItem>
<AccordionItem 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.
</AccordionItem>
</Accordion>
## 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/(welcome)/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
<Accordion type="single">
<AccordionItem title="Constraints">
Constraints:
• `1 <= s.length <= 10^5`
• `s` consists of only lowercase English letters.
</AccordionItem>
<AccordionItem 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`.
</AccordionItem>
</Accordion>
## 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/(welcome)/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
<Accordion type="single">
<AccordionItem title="Constraints">
Constraints:
• `1 <= s.length <= 5 * 10^5`
• `s` consists of uppercase and lowercase English letters and digits.
</AccordionItem >
<AccordionItem 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.
</AccordionItem >
</Accordion>
## 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/(welcome)/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
docs/.gitignore
-2
View File
@@ -1,2 +0,0 @@
.blume/
dist/
docs/guides/index.mdx
-11
View File
@@ -1,11 +0,0 @@
---
title: Guides
description: News and writing from the team.
type: blog
---
<CardGroup cols={2}>
<Card title="Introducing Blume" href="/blog/introducing-blume">
Why we built a markdown-first docs framework.
</Card>
</CardGroup>
docs/guides/introducing-blume.mdx
-8
View File
@@ -1,8 +0,0 @@
---
title: Introducing Blume
type: blog
date: 2026-06-22
description: Why we built a markdown-first docs framework.
---
Documentation should be fast, AI-ready, and zero-config — down to not needing a starter template at all. Here's the thinking behind Blume.