50 days of LeetCode - JavaScript Algorithms Coding Interview

Check for a valid mountain by a strictly increasing subarray from the start to a point, then a strictly decreasing subarray to the end. Arrays shorter than three return false.

Identify an increasing subsequence with a first loop, then a decreasing subsequence with a second loop, tracking ends to ensure the pattern reaches the array end.

Walk through a pseudocode algorithm that detects a mountain array by finding an increasing subsequence, then a decreasing subsequence, with O(n) time and O(1) space.

Implement the valid mountain array function by climbing up while the sequence increases, then descending, and return true if the entire array is consumed, otherwise false.

Solve the boats to save people problem: given weights and a limit, minimize boats by placing at most two people per boat with sum not exceeding the limit.

Sort the array to access heaviest and lightest candidates. Use a two-pointers approach to pair compatible candidates and count boats, maximizing two-person boats.

Walks through a pseudocode driven two-pointer solution to the boat problem: sort weights, pair lightest with heaviest within the limit, count boats, and analyze time and space complexity.

Sort the array ascending, set two end pointers, and pair lightest with heaviest to minimize boats. If pairing fails, assign the heaviest alone and increment boats, then test on LeetCode.

Move all zeros to the end of an array while preserving the relative order of non-zero elements, using a brute-force approach with a temporary output array.

Walk through a brute force pseudocode that builds an output array of non-zero elements, then appends zeros; analyze time complexity O(n) and O(n-m) and space O(n).

Use an in-place two-pointer approach to move non-zero elements to the front, tracking count with j. Then fill the remaining positions with zeros.

Walk through the optimal in‑place move zeros solution, using a j pointer to compact nonzeros at the front, then fill the rest with zeros, achieving O(n+m) time and O(1) space.

Implement in-place zero-movement by relocating non-zero elements to the front while preserving their order, and filling the remainder with zeros using a zero index and a non-zero index.

Explore the longest substring without repeating characters problem, focusing on contiguous substrings, and distinguish it from subsequences with examples, edge cases, empty string. Preview a simple brute force approach.

Explore a brute-force approach to finding the longest substring without repeating characters, using hash maps for each starting position to expand substrings until a duplicate appears.

Follow a pseudocode walkthrough that starts from brute force and demonstrates a sliding window approach to find the longest substring without repeating characters, using a seen characters map.

Use the sliding window with left and right pointers, track last-seen indices in a map, and adjust left as the max between its current value and last index plus one.

Walk through a sliding window solution for the longest substring without repeating characters, using left and right pointers and a seen character map, with O(n) time and O(n) space.

Explore a brute force pseudocode walkthrough for finding the first and last indices of a target in an array, using linear scans and analyzing time (O(n)) and space (O(1)) complexities.

Use binary search on the sorted array to find the first and last positions of the target by locating the leftmost and rightmost occurrences.

Follow a pseudocode walkthrough of binary search to find the first and last occurrences of a target in a sorted array, using two pointers, mid calculations, and boundary checks.

Walk through two-pointer binary search to find the last occurrence of a target in a sorted array, updating left and right boundaries, and analyzing O(log n) time with constant space.

Implement binary search to locate the first and last positions of a target in a sorted array, returning -1 when not found.

Explore the first bad version problem with brute force using isBadVersion, noting that once a version is bad, all later versions are bad, with O(n) time and O(1) space.

Apply binary search to find the first bad version using isBadVersion. Narrow the range with left and right pointers until left equals right, then return the first bad version.

Identify the first bad version using a binary search with two pointers, mid calculations, and an isBadVersion API, achieving O(log n) time and O(1) space.

Implement the binary search approach to identify the first bad version among many, using left and right pointers, mid checks, and the isBadVersion function.

Identify the missing number in an array of n distinct numbers from zero to n. Recognize that the missing value completes the zero-to-n sequence.

Implement the brute force approach by sorting the input, then scanning consecutive elements to detect a gap greater than one and return the missing number (current minus one).

Apply Gauss's formula to compute the sum from zero to n and reveal the missing number by subtracting actual sum from expected sum, in O(n) time and O(1) space.

Implement the missing number function by tallying input numbers, computing the expected total with Gauss's formula n(n+1)/2, and returning the difference as the missing number.

Count the number of prime numbers less than a given nonnegative n using a brute force approach that checks divisibility from two to n and tracks primes.

Walk through a pseudocode brute-force approach to finding primes below a given input, using an is-prime flag and nested loops, with O(n^2) time and O(1) space.

Learn an optimal sieve approach to identify primes up to n by marking non-prime multiples, starting from i times i and stopping at the square root of n.

Implement a primes counting function using an isprime array, mark multiples up to sqrt(n) as non-prime, and count true entries to return the prime count.

Explore the single number problem and its unsorted array constraints, and learn a brute force approach using a hash map to count occurrences and locate the unique element.

Apply a better approach to find the single non-duplicate in an array using a set of unique elements and the formula 2 times the sum of unique minus actual sum.

Implement a function that finds the number that appears once in a list of integers by counting occurrences with a map and returning the unique element.

Explore optimal approach that achieves linear time with constant space using xor on binary bits to cancel duplicates. Learn how binary representations and xor reveal the number that occurs once.

Use a bitwise xor to cancel out pairs and reveal the single occurrence in a list of integers. Initialize the result to zero and return the unique value.