JavaScript & LeetCode | The Interview Bootcamp

Explore string problems such as palindrome checks and anagrams, learning to determine if a word reads the same forwards and backwards or if two words can be rearranged to match.

Apply a two-pointer approach to check palindromes in LeetCode problem 125 by sanitizing the input to lowercase and removing non-alphanumeric characters, then compare mirrored characters from both ends.

Use the expand around center method to find the longest palindromic substring, treating odd and even centers with left and right pointers, and track the start index and max length.

Explore solving the longest substring without repeating characters using a sliding window, hash map tracking last seen indices, and a linear-time approach that grows and shrinks the window.

Implement a sliding window algorithm with a chars map to track earliest indices, updating the start on duplicates to compute the longest substring length.

Solve LeetCode 242 valid anagrams by comparing lengths, building a char counts object for s, and decrementing as you scan t, returning false on mismatches; tests pass.

Solve LeetCode 49 group anagrams in JavaScript by sorting each word's characters to form keys, grouping words in an object, and returning the array of anagram groups.

Learn a stack-based solution to LeetCode valid parentheses (LC 20) that uses a pairs map to push left braces and pop on matches, validating strings in O(n) time and space.

Explore dynamic programming with LeetCode 70 climb stairs, derive a Fibonacci pattern for subproblems, implement a ways array and a space-optimized O(1) solution.

Solve LeetCode problem 198 house robber with dynamic programming, building subproblems to maximize loot while skipping adjacent houses, and implement a linear-time recurrence that can be optimized from O(n) space.

Explore a dynamic programming approach to LeetCode Jump Game 55, using a boolean reachability array to determine if the last step is reachable, via a pseudocode walkthrough.

Solve the jump game using a dp array and i and j pointers to track reachable steps, validating with the test suite, with time complexity o(n^2) and space o(n).

Use a dynamic programming approach to the longest increasing subsequence, with a dp array initialized to ones representing LIS at each position, updating when a[j] > a[i] and returning max.

explains how to solve the longest increasing subsequence with a dynamic programming approach using a dp array, handling edge cases, and analyzing time and space complexity.

Apply dynamic programming to the coin change problem (lc 322): build a min-coin table up to the amount, initialize to infinity, base case amount zero, and update with each coin.

Implement a dynamic programming solution for coin change using a dp array of amount plus one to compute the minimum coins, or -1 if impossible.

Apply dynamic programming to LeetCode 62 unique paths by building a dp matrix with ones in the first row and column, then compute bottom-right from top and left neighbors.

Explore array-based leetcode problems by calculating sums from numbers in an input array, starting with two-sum and three-sum targets and building toward harder challenges.

Apply a hash-table approach in JavaScript to solve contains duplicate (LC 217) by tracking visited numbers, achieving O(n) time and O(n) space, and passing tests.

Solve the product of array except self (lc 238) in linear time using left and right products with a single output array in two passes in JavaScript.

solve container with most water in linear time by using left and right pointers, calculating area with the smaller height, and moving the smaller wall until they meet.

Learn to determine the best time to buy and sell stock (LC #121) for maximum profit using a single pass, tracking the cheapest price and the max profit.

Solve the two sum problem in linear time using a hash table to store visited numbers and their indices in one pass. Compute complements and return their indices.

learn to solve 3sum (lc #15) by sorting an array, using two pointers to find triplets that sum to zero, and skipping duplicates to avoid repeats.

Implement the 3Sum solution with a sorted array and left-right pointers to find triplets summing to zero, while skipping duplicates and achieving O(n^2) time.

Solve Leetcode problem 53 maximum subarray using dynamic programming, building on the house robber approach to compute a dp array that tracks the max sum up to each index.

Solve the maximum subarray problem (lc #53) with a dp array, transforming the input in place to achieve O(n) time and O(1) space, verified by tests.

Explore the max product subarray problem from leetcode 152, using dynamic programming with parallel max and min till index arrays to handle negative numbers and contiguity.

Implement a modified binary search with left and right pointers to find the minimum in a rotated sorted array, handling edge cases and inflection points in O(log n) time.

Master searching in a rotated sorted array in O(log n) time by finding the inflection index and running binary searches on the two sorted halves.

implement the rotated sorted array search by creating two helpers, find min index and binary search, then determine the target's index by searching both halves and returning the larger index.

Explore intervals and overlapping time slots with real-life examples like 8 to 9, 8:30 to 9:30, and 12 to 1 to decide whether all calls fit or merging is needed.

Tackles leetcode problem 252 to determine if meetings can be attended. Uses starts and ends arrays, sorts them, and detects overlap by comparing starts[i+1] to ends[i], false on conflict, true.

Solve non-overlapping intervals by sorting by start times and removing the interval with the largest end when overlaps occur, in-place with O(n log n) time and O(1) space.

Sort intervals by start times and merge overlaps by extending the last interval, pushing non-overlapping intervals to the result, with O(n log n) time and O(1) space.

Master spiral matrix traversal by implementing a clockwise pattern using top, bottom, left, right pointers and a direction variable to populate a result array in LeetCode 54.

Implement the spiral order algorithm from Leetcode, using top, bottom, left, right and a direction loop to fill a spiral array, then state O(nm) time and O(n) space.

Explore solving set matrix zeros in place with constant space by using the first row and column as markers. Follow a six-step plan to track zeros and apply in-place updates.

Solve the set zeros problem using the pseudo code, flag the first row and column, update in place, and confirm with tests and LeetCode (time complexity o(n*m), space complexity o(1)).

Solve word search by using a depth-first search on a letter matrix, starting from cells matching the first letter, exploring four directions and marking and unmarking to avoid reuse.

Traverse input linked lists to create new lists, remove nodes, and merge two lists, including cases with two input lists.

Learn to reverse a linked list (lc 206) by using a previous and current pointer, iterating with a while loop, and returning the new head to pass LeetCode tests.

Detect a cycle in a linked list using slow and fast pointers. Return true for circular lists; false when a tail leads to null, using O(n) time and O(1) space.

Apply a two-pointer approach with a dummy head to remove the nth node from the end of a linked list, returning the updated head with O(n) time and O(1) space.

Merge two sorted linked lists with a dummy head and tail pointer to iteratively select the smaller node. Attach remainder when a list ends and achieve O(n+m) time, O(1) space.

Explore tree data structures and compare them to linked lists, focusing on binary trees and binary search trees, with a quick refresher and practical prompts.

Count islands in a matrix by scanning each cell, sinking each found island with DFS to mark connected land as water, counting one per island, even when touching the corners.

Invert a binary tree by swapping each node's left and right children using a helper recursion and a temporary variable, per LC #226.

Solve LeetCode 104 max depth of a binary tree with a recursive helper that tracks current depth, updates max depth at null nodes, and traverses left and right.

Explore binary tree level order traversal (lc #102) using a recursive helper to fill an array of level subarrays, and analyze time and space complexity.

Learn to determine if two trees are identical using a recursive helper that compares nodes p and q, with time complexity O(P+Q) and space O(1) (or O(P+Q) with recursion).

Validate binary search tree (lc #98) with a recursive helper enforcing min and max bounds. Traverse left and right, treat null as infinity, and achieve O(n) time.

Explore how to find the lowest common ancestor in a binary search tree using its property to move left or right from the root, iteratively or recursively.

Iteratively find the lowest common ancestor in a binary search tree by traversing from the root and returning the current node once found based on p and q values.

Finish this course and prepare for your next technical interview, increasing your chances of landing your dream job. Explore more courses at education.com for a full list of offerings.