mirror of
https://github.com/prdlk/leetcode.git
synced 2026-11-02 21:22:43 +00:00
docs: rename category folders to remove parentheses and update heap meta title
This commit is contained in:
Prad Nukala committed
1 parent
c2a8a31ede
commit
edd37ed0e6
84 files changed
+3
-3
No files matched your search
@@ -0,0 +1,77 @@
|
||||
---
|
||||
title: '1365. How Many Numbers Are Smaller Than the Current Number'
|
||||
description: 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]
|
||||
sidebar:
|
||||
label: 'How Many Numbers Are Smaller Than the Current Number'
|
||||
badge: 'Easy'
|
||||
---
|
||||
|
||||
<Badge variant="accent">Array</Badge>
|
||||
|
||||
### Example 1:
|
||||
- Input: `nums = [8,1,2,2,3]`
|
||||
- Output: `[4,0,1,1,3]`
|
||||
- Explanation: For `nums[0]=8` there exist four smaller numbers than it (`1`, `2`, `2` and `3`). For `nums[1]=1` does not exist any smaller number than it. For `nums[2]=2` there exist one smaller number than it (`1`). For `nums[3]=2` there exist one smaller number than it (`1`). For `nums[4]=3` there exist three smaller numbers than it (`1`, `2` and `2`).
|
||||
|
||||
### Example 2:
|
||||
- Input: `nums = [6,5,4,8]`
|
||||
- Output: `[2,1,0,3]`
|
||||
|
||||
### Example 3:
|
||||
- Input: `nums = [7,7,7,7]`
|
||||
- Output: `[0,0,0,0]`
|
||||
|
||||
### Constraints:
|
||||
|
||||
- `2 <= nums.length <= 500`
|
||||
- `0 <= nums[i] <= 100`
|
||||
|
||||
## Approach
|
||||
|
||||
```mermaid
|
||||
flowchart TD
|
||||
S(["smallerNumbersThanCurrent(nums)"]) --> F["freq: count every value in nums"]
|
||||
F --> O["sorted = keys of freq, ascending"]
|
||||
O --> I["count = 0, smaller = {}"]
|
||||
I --> L{"more num in sorted?"}
|
||||
L -- yes --> A["smaller[num] = count — everything already passed is smaller"]
|
||||
A --> B["count += freq[num]"]
|
||||
B --> L
|
||||
L -- no --> M(["return nums.map(n => smaller[n])"])
|
||||
```
|
||||
|
||||
## Solution
|
||||
|
||||
```js
|
||||
/**
|
||||
* @param {number[]} nums
|
||||
* @return {number[]}
|
||||
*/
|
||||
|
||||
var smallerNumbersThanCurrent = function (nums) {
|
||||
// Step 1: Begin by initializing a [Frequency Map]()
|
||||
const freq = {};
|
||||
for (let n of nums) freq[n] = (freq[n] || 0) + 1;
|
||||
|
||||
// Step 2: Sort the numbers by ascending order
|
||||
const sorted = Object.keys(freq).sort((a, b) => a - b);
|
||||
|
||||
// Step 3: Init a count of numbers smaller than the active number
|
||||
let count = 0;
|
||||
|
||||
// Step 4: Init a map to track number of values smaller for each number
|
||||
const smaller = {};
|
||||
|
||||
// Step 5: Iterate over the sorted list
|
||||
for (let num of sorted) {
|
||||
// Set count for active number
|
||||
smaller[num] = count;
|
||||
|
||||
// Update the count by frequency
|
||||
count += freq[num];
|
||||
}
|
||||
|
||||
// Step 6: Use original list and find number of smaller values than it
|
||||
return nums.map((n) => smaller[n]);
|
||||
};
|
||||
```
|
||||
@@ -0,0 +1,69 @@
|
||||
---
|
||||
title: '1413. Minimum Value to Get Positive Step by Step Sum'
|
||||
description: Given an array of integers nums, you start with an initial positive value startValue
|
||||
sidebar:
|
||||
label: 'Minimum Value to Get Positive Step by Step Sum'
|
||||
badge: 'Easy'
|
||||
---
|
||||
|
||||
<Badge variant="accent">Array</Badge>
|
||||
|
||||
### Example 1:
|
||||
- Input: `nums = [-3,2,-3,4,2]`
|
||||
- Output: `5`
|
||||
- Explanation: If you choose `startValue = 4`, in the third iteration your step by step sum is less than `1`.
|
||||
|
||||
```
|
||||
step by step sum
|
||||
startValue = 4 | startValue = 5 | nums
|
||||
(4 -3 ) = 1 | (5 -3 ) = 2 | -3
|
||||
(1 +2 ) = 3 | (2 +2 ) = 4 | 2
|
||||
(3 -3 ) = 0 | (4 -3 ) = 1 | -3
|
||||
(0 +4 ) = 4 | (1 +4 ) = 5 | 4
|
||||
(4 +2 ) = 6 | (5 +2 ) = 7 | 2
|
||||
```
|
||||
|
||||
### Example 2:
|
||||
- Input: `nums = [1,2]`
|
||||
- Output: `1`
|
||||
- Explanation: Minimum start value should be positive.
|
||||
|
||||
### Example 3:
|
||||
- Input: `nums = [1,-2,-3]`
|
||||
- Output: `5`
|
||||
|
||||
### Constraints:
|
||||
|
||||
- `1 <= nums.length <= 100`
|
||||
- `-100 <= nums[i] <= 100`
|
||||
|
||||
## Approach
|
||||
|
||||
```mermaid
|
||||
flowchart TD
|
||||
S(["minStartValue(nums)"]) --> I["prefix = [nums[0]]"]
|
||||
I --> L{"more i in 1..n-1?"}
|
||||
L -- yes --> P["prefix.push(prefix[i-1] + nums[i])"]
|
||||
P --> L
|
||||
L -- no --> M["min = smallest running total"]
|
||||
M --> R(["return max(1, 1 - min) — lift the dip to 1"])
|
||||
```
|
||||
|
||||
## Solution
|
||||
|
||||
```js
|
||||
/**
|
||||
* @param {number[]} nums
|
||||
* @return {number}
|
||||
*/
|
||||
var minStartValue = function(nums) {
|
||||
let prefix = [nums[0]];
|
||||
// Make prefix sum start at 1 after initializing seed value
|
||||
for (let i = 1; i < nums.length; i++){
|
||||
prefix.push(prefix[i - 1] + nums[i]);
|
||||
}
|
||||
|
||||
let min = Math.min(...prefix);
|
||||
return Math.max(1, 1 - min);
|
||||
};
|
||||
```
|
||||
@@ -0,0 +1,58 @@
|
||||
---
|
||||
title: '1426. Counting Elements'
|
||||
description: Given an integer array arr, count how many elements x there are, such that x + 1 is also in arr. If there are duplicates in arr, count them separately
|
||||
sidebar:
|
||||
label: 'Counting Elements'
|
||||
badge: 'Easy'
|
||||
---
|
||||
|
||||
<Badge variant="accent">Array</Badge>
|
||||
|
||||
### Example 1:
|
||||
- Input: `arr = [1,2,3]`
|
||||
- Output: `2`
|
||||
- Explanation: `1` and `2` are counted cause `2` and `3` are in `arr`.
|
||||
|
||||
### Example 2:
|
||||
- Input: `arr = [1,1,3,3,5,5,7,7]`
|
||||
- Output: `0`
|
||||
- Explanation: No numbers are counted, cause there is no `2`, `4`, `6`, or `8` in `arr`.
|
||||
|
||||
### Constraints:
|
||||
|
||||
- `1 <= arr.length <= 1000`
|
||||
- `0 <= arr[i] <= 1000`
|
||||
|
||||
## Approach
|
||||
|
||||
```mermaid
|
||||
flowchart TD
|
||||
S(["countElements(arr)"]) --> I["arrSet = Set(arr), count = 0"]
|
||||
I --> L{"more n in arr?"}
|
||||
L -- no --> E(["return count"])
|
||||
L -- yes --> H{"arrSet has n + 1?"}
|
||||
H -- yes --> C["count++"]
|
||||
C --> L
|
||||
H -- no --> L
|
||||
```
|
||||
|
||||
## Solution
|
||||
|
||||
```js
|
||||
/**
|
||||
* @param {number[]} arr
|
||||
* @return {number}
|
||||
*/
|
||||
var countElements = function(arr) {
|
||||
let arrSet = new Set(arr);
|
||||
let count = 0;
|
||||
|
||||
for (let n of arr) {
|
||||
let sum = n + 1;
|
||||
if (arrSet.has(sum)) {
|
||||
count++;
|
||||
}
|
||||
}
|
||||
return count;
|
||||
};
|
||||
```
|
||||
@@ -0,0 +1,55 @@
|
||||
---
|
||||
title: '1480. Running Sum of 1d Array'
|
||||
description: Given an array nums. We define a running sum of an array as runningSum[i] = sum(nums[0]…nums[i])
|
||||
sidebar:
|
||||
label: 'Running Sum of 1d Array'
|
||||
badge: 'Easy'
|
||||
---
|
||||
|
||||
<Badge variant="accent">Array</Badge>
|
||||
|
||||
### Example 1:
|
||||
- Input: `nums = [1,2,3,4]`
|
||||
- Output: `[1,3,6,10]`
|
||||
- Explanation: Running sum is obtained as follows: `[1, 1+2, 1+2+3, 1+2+3+4]`.
|
||||
|
||||
### Example 2:
|
||||
- Input: `nums = [1,1,1,1,1]`
|
||||
- Output: `[1,2,3,4,5]`
|
||||
- Explanation: Running sum is obtained as follows: `[1, 1+1, 1+1+1, 1+1+1+1, 1+1+1+1+1]`.
|
||||
|
||||
### Example 3:
|
||||
- Input: `nums = [3,1,2,10,1]`
|
||||
- Output: `[3,4,6,16,17]`
|
||||
|
||||
### Constraints:
|
||||
|
||||
- `1 <= nums.length <= 1000`
|
||||
- `-10^6 <= nums[i] <= 10^6`
|
||||
|
||||
## Approach
|
||||
|
||||
```mermaid
|
||||
flowchart TD
|
||||
S(["runningSum(nums)"]) --> I["prefix = [nums[0]]"]
|
||||
I --> L{"more i in 1..n-1?"}
|
||||
L -- yes --> P["prefix.push(prefix[i-1] + nums[i])"]
|
||||
P --> L
|
||||
L -- no --> E(["return prefix"])
|
||||
```
|
||||
|
||||
## Solution
|
||||
|
||||
```js
|
||||
/**
|
||||
* @param {number[]} nums
|
||||
* @return {number[]}
|
||||
*/
|
||||
var runningSum = function(nums) {
|
||||
let prefix = [nums[0]];
|
||||
for (let i = 1; i < nums.length; i++){
|
||||
prefix.push(prefix[i - 1] + nums[i]);
|
||||
}
|
||||
return prefix;
|
||||
};
|
||||
```
|
||||
@@ -0,0 +1,58 @@
|
||||
---
|
||||
title: '1636. Sort Array by Increasing Frequency'
|
||||
description: 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
|
||||
sidebar:
|
||||
label: 'Sort Array by Increasing Frequency'
|
||||
badge: 'Easy'
|
||||
---
|
||||
|
||||
<Badge variant="accent">Array</Badge>
|
||||
|
||||
### Example 1:
|
||||
- Input: `nums = [1,1,2,2,2,3]`
|
||||
- Output: `[3,1,1,2,2,2]`
|
||||
- Explanation: `'3'` has a frequency of `1`, `'1'` has a frequency of `2`, and `'2'` has a frequency of `3`.
|
||||
|
||||
### Example 2:
|
||||
- Input: `nums = [2,3,1,3,2]`
|
||||
- Output: `[1,3,3,2,2]`
|
||||
- Explanation: `'2'` and `'3'` both have a frequency of `2`, so they are sorted in decreasing order.
|
||||
|
||||
### Example 3:
|
||||
- Input: `nums = [-1,1,-6,4,5,-6,1,4,1]`
|
||||
- Output: `[5,-1,4,4,-6,-6,1,1,1]`
|
||||
|
||||
### Constraints:
|
||||
|
||||
- `1 <= nums.length <= 100`
|
||||
- `-100 <= nums[i] <= 100`
|
||||
|
||||
## Approach
|
||||
|
||||
```mermaid
|
||||
flowchart TD
|
||||
S(["frequencySort(nums)"]) --> F["freq: count every value in nums"]
|
||||
F --> C["sort nums with a two-key comparator"]
|
||||
C --> K1["primary: freq[a] - freq[b] — rarer first"]
|
||||
C --> K2["tie-break: b - a — larger value first"]
|
||||
K1 --> R(["return nums"])
|
||||
K2 --> R
|
||||
```
|
||||
|
||||
## Solution
|
||||
|
||||
```js
|
||||
/**
|
||||
* @param {number[]} nums
|
||||
* @return {number[]}
|
||||
*/
|
||||
var frequencySort = function (nums) {
|
||||
const freq = {};
|
||||
for (let n of nums) freq[n] = (freq[n] || 0) + 1;
|
||||
return nums.sort((a, b) => freq[a] - freq[b] || b - a);
|
||||
};
|
||||
```
|
||||
|
||||
## Explanation
|
||||
|
||||
<YouTube id="Evq1SfUbhBg" title="Sort Array by Increasing Frequency - Leetcode 1636 - Python" />
|
||||
@@ -0,0 +1,71 @@
|
||||
---
|
||||
title: '268. Missing Number'
|
||||
description: Given an array nums containing n distinct numbers in the range [0, n], return the only number in the range that is missing from the array
|
||||
sidebar:
|
||||
label: 'Missing Number'
|
||||
badge: 'Easy'
|
||||
---
|
||||
|
||||
<Badge variant="accent">Array</Badge>
|
||||
|
||||
::::warning
|
||||
Could you implement a solution using only O(1) extra space complexity and O(n) runtime complexity?
|
||||
::::
|
||||
|
||||
### Example 1:
|
||||
- Input: `nums = [3,0,1]`
|
||||
- Output: `2`
|
||||
- Explanation: `n = 3` since there are `3` numbers, so all numbers are in the range `[0,3]`. `2` is the missing number in the range since it does not appear in `nums`.
|
||||
|
||||
### Example 2:
|
||||
- Input: `nums = [0,1]`
|
||||
- Output: `2`
|
||||
- Explanation: `n = 2` since there are `2` numbers, so all numbers are in the range `[0,2]`. `2` is the missing number in the range since it does not appear in `nums`.
|
||||
|
||||
### Example 3:
|
||||
- Input: `nums = [9,6,4,2,3,5,7,0,1]`
|
||||
- Output: `8`
|
||||
- Explanation: `n = 9` since there are `9` numbers, so all numbers are in the range `[0,9]`. `8` is the missing number in the range since it does not appear in `nums`.
|
||||
|
||||
### Constraints:
|
||||
|
||||
- `n == nums.length`
|
||||
- `1 <= n <= 10^4`
|
||||
- `0 <= nums[i] <= n`
|
||||
- All the numbers of `nums` are unique.
|
||||
|
||||
## Approach
|
||||
|
||||
```mermaid
|
||||
flowchart TD
|
||||
S(["missingNumber(nums)"]) --> I["numSet = Set(nums), expectedCount = n + 1"]
|
||||
I --> L{"more i in 0..expectedCount-1?"}
|
||||
L -- yes --> Q{"numSet has i?"}
|
||||
Q -- no --> R(["return i"])
|
||||
Q -- yes --> L
|
||||
L -- no --> E(["return -1"])
|
||||
```
|
||||
|
||||
## Solution
|
||||
|
||||
```js
|
||||
/**
|
||||
* @param {number[]} nums
|
||||
* @return {number}
|
||||
*/
|
||||
var missingNumber = function(nums) {
|
||||
const numSet = new Set(nums);
|
||||
const expectedCount = nums.length + 1;
|
||||
|
||||
for (let i = 0; i < expectedCount; i++){
|
||||
if(!numSet.has(i)){
|
||||
return i;
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
};
|
||||
```
|
||||
|
||||
## Explanation
|
||||
|
||||
<YouTube id="WnPLSRLSANE" title="Missing Number - Blind 75 - Leetcode 268 - Python" />
|
||||
@@ -0,0 +1,73 @@
|
||||
---
|
||||
title: '271. Encode and Decode Strings'
|
||||
description: Design an algorithm to encode a list of strings to a string. The encoded string is then sent over the network and is decoded back to the original list of strings
|
||||
sidebar:
|
||||
label: 'Encode and Decode Strings'
|
||||
badge: 'Medium'
|
||||
---
|
||||
|
||||
<Badge variant="accent">Array</Badge>
|
||||
|
||||
::::warning
|
||||
Could you write a generalized algorithm to work on any possible set of characters?
|
||||
::::
|
||||
|
||||
### Example 1:
|
||||
- Input: `dummy_input = ["Hello","World"]`
|
||||
- Output: `["Hello","World"]`
|
||||
- Explanation: Machine `1`: Codec encoder = new Codec(); String msg = encoder.encode(strs); Machine `1` ---msg---> Machine `2` Machine `2`: Codec decoder = new Codec(); `String[] strs` = decoder.decode(msg);
|
||||
|
||||
### Example 2:
|
||||
- Input: `dummy_input = [""]`
|
||||
- Output: `[""]`
|
||||
|
||||
### Constraints:
|
||||
|
||||
- `1 <= strs.length <= 200`
|
||||
- `0 <= strs[i].length <= 200`
|
||||
- `strs[i]` contains any possible characters out of 256 valid ASCII characters.
|
||||
|
||||
## Approach
|
||||
|
||||
::::warning
|
||||
The diagram traces the code below literally. That code does not solve the problem: both `encode` and `decode` have only a docstring for a body, so each returns `None` and `codec.decode(codec.encode(strs))` yields `None` instead of `strs`.
|
||||
::::
|
||||
|
||||
```mermaid
|
||||
flowchart TD
|
||||
subgraph state["state — Codec holds no fields"]
|
||||
X["Codec() — nothing is stored between encode and decode"]
|
||||
end
|
||||
subgraph encode["encode(strs)"]
|
||||
E1["docstring only — no statement runs"] --> E2(["return None"])
|
||||
end
|
||||
subgraph decode["decode(s)"]
|
||||
D1["docstring only — no statement runs"] --> D2(["return None"])
|
||||
end
|
||||
state --> encode
|
||||
state --> decode
|
||||
```
|
||||
|
||||
## Solution
|
||||
|
||||
```py
|
||||
class Codec:
|
||||
def encode(self, strs: List[str]) -> str:
|
||||
"""Encodes a list of strings to a single string.
|
||||
"""
|
||||
|
||||
|
||||
def decode(self, s: str) -> List[str]:
|
||||
"""Decodes a single string to a list of strings.
|
||||
"""
|
||||
|
||||
|
||||
|
||||
# Your Codec object will be instantiated and called as such:
|
||||
# codec = Codec()
|
||||
# codec.decode(codec.encode(strs))
|
||||
```
|
||||
|
||||
## Explanation
|
||||
|
||||
<YouTube id="B1k_sxOSgv8" title="Encode and Decode Strings - Leetcode 271 - Python" />
|
||||
@@ -0,0 +1,3 @@
|
||||
import { defineMeta } from "blume";
|
||||
|
||||
export default defineMeta({ title: "Array" });
|
||||
Reference in new issue
Block a user