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

chore: clean up obsolete examples

Browse Source
This commit is contained in:
Prad Nukala committed 2026-09-24 15:32:21 -04:00
1 parent 3445c47ad2
commit 403a2d7f23
18 files changed
+8 -1034
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

work/1/Easy/Array/1365.how-many-numbers-are-smaller-than-the-current-number.js
-77
View File
@@ -1,77 +0,0 @@
/*
* 1365. How Many Numbers Are Smaller Than the Current Number
* Difficulty: Easy
* https://leetcode.com/problems/how-many-numbers-are-smaller-than-the-current-number/
*
* ──────────────────────────────────────────────────
*
* 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].
*
* Return the answer in an array.
*
*
*
* 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
*/
/**
* @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]);
};
work/1/Easy/Array/1413.minimum-value-to-get-positive-step-by-step-sum.js
-66
View File
@@ -1,66 +0,0 @@
/*
* 1413. Minimum Value to Get Positive Step by Step Sum
* Difficulty: Easy
* https://leetcode.com/problems/minimum-value-to-get-positive-step-by-step-sum/
*
* ──────────────────────────────────────────────────
*
* Given an array of integers nums, you start with an initial positive
* value startValue.
*
* In each iteration, you calculate the step by step sum of startValue
* plus elements in nums (from left to right).
*
* Return the minimum positive value of startValue such that the step by
* step sum is never less than 1.
*
*
*
* 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
*/
/**
* @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);
};
work/1/Easy/Array/1426.counting-elements.js
-51
View File
@@ -1,51 +0,0 @@
/*
* 1426. Counting Elements
* Difficulty: Easy
* https://leetcode.com/problems/counting-elements/
*
* ──────────────────────────────────────────────────
*
* 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.
*
*
*
* 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
*/
/**
* @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;
};
work/1/Easy/Array/1480.running-sum-of-1d-array.js
-53
View File
@@ -1,53 +0,0 @@
/*
* 1480. Running Sum of 1d Array
* Difficulty: Easy
* https://leetcode.com/problems/running-sum-of-1d-array/
*
* ──────────────────────────────────────────────────
*
* Given an array nums. We define a running sum of an array as
* runningSum[i] = sum(nums[0]&hellip;nums[i]).
*
* Return the running sum of nums.
*
*
*
* 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
*/
/**
* @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;
};
work/1/Easy/Array/1636.sort-array-by-increasing-frequency.js
-52
View File
@@ -1,52 +0,0 @@
/*
* 1636. Sort Array by Increasing Frequency
* Difficulty: Easy
* https://leetcode.com/problems/sort-array-by-increasing-frequency/
*
* ──────────────────────────────────────────────────
*
* 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.
*
*
*
* 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
*/
/**
* @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);
};
work/1/Easy/Array/217.contains-duplicate.js
-62
View File
@@ -1,62 +0,0 @@
/*
* 217. Contains Duplicate
* Difficulty: Easy
* https://leetcode.com/problems/contains-duplicate/
*
* ──────────────────────────────────────────────────
*
* Given an integer array nums, return true if any value appears at
* least twice in the array, and return false if every element is
* distinct.
*
*
*
* Example 1:
*
* Input: nums = [1,2,3,1]
*
* Output: true
*
* Explanation:
*
* The element 1 occurs at the indices 0 and 3.
*
* Example 2:
*
* Input: nums = [1,2,3,4]
*
* Output: false
*
* Explanation:
*
* All elements are distinct.
*
* Example 3:
*
* Input: nums = [1,1,1,3,3,4,3,2,4,2]
*
* Output: true
*
*
*
* Constraints:
*
* • 1 <= nums.length <= 10^5
*
* • -10^9 <= nums[i] <= 10^9
*/
/**
* @param {number[]} nums
* @return {boolean}
*/
var containsDuplicate = function(nums) {
const freq = {};
for (let n of nums) {
freq[n] = (freq[n] || 0) + 1;
if (freq[n] >= 2) {
return true;
}
}
return false;
};
work/1/Easy/Array/217.contains-duplicate.py
+6 -5
View File
@@ -9,7 +9,7 @@ Given an integer array nums, return true if any value appears at
least twice in the array, and return false if every element is
distinct.
Example 1:
@@ -37,15 +37,16 @@ Input: nums = [1,1,1,3,3,4,3,2,4,2]
Output: true
Constraints:
• 1 <= nums.length <= 10^5
• 1 <= nums.length <= 10^5
• -10^9 <= nums[i] <= 10^9
• -10^9 <= nums[i] <= 10^9
"""
class Solution:
def containsDuplicate(self, nums: List[int]) -> bool:
return len(set(nums)) != len(nums)
work/1/Easy/Array/268.missing-number.js
-90
View File
@@ -1,90 +0,0 @@
/*
* 268. Missing Number
* Difficulty: Easy
* https://leetcode.com/problems/missing-number/
*
* ──────────────────────────────────────────────────
*
* 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.
*
*
*
* 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.
*
*
*
* Follow up: Could you implement a solution using only O(1) extra space
* complexity and O(n) runtime complexity?
*/
/**
* @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;
};