50 day of LeetCode in PHP: Algorithms coding interview

Explore solving the container with the most water problem by selecting two heights from an array, computing area as min height times index difference.

Use a brute force approach by trying every pair of walls, calculating area as min(height i, height j) times (j - i), and updating the maximum area.

Explore a brute force pseudocode walkthrough of the container problem, computing max area using min height and index difference, with o(n^2) time and o(1) space.

Apply the two-pointer technique from the array ends, compute area as min(height_left, height_right) times width, and move the pointer at the smaller wall to maximize the container area.

Use a two-pointer approach with left and right indexes to compute area as the min height times distance, updating the max area while moving the shorter wall.

Implement a two-pointer algorithm to compute the maximum area by updating max area with min(height left, height right) times their width, and move the smaller height pointer.

Identify an increasing subsequence by looping and comparing each element to the previous. Save the end of the increasing run, then verify the ending decreasing subsequence reaches the array end.

Follow a pseudocode walkthrough to detect a valid mountain array by scanning for an increasing subsequence, then a decreasing subsequence, with O(n) time and O(1) space.

Master the boats to save people problem by pairing weights from the array under a limit, so each boat carries at most two people and minimizes the total boats needed.

master a greedy two-pointer approach to the boat pairing problem: sort weights, pair the heaviest with the lightest when their sum fits the limit, otherwise ship the heaviest alone.

Sort the weights, then use a two-pointer approach to pair the heaviest and lightest within the limit, counting boats. The time complexity is O(n log n) and space is O(n).

Move all zeros to the end while preserving the order of non-zero elements by first collecting non-zeros in a new array and then appending zeros for the remaining positions.

Develop an in-place approach to move non-zero elements to the front of an array using two pointers, tracking non-zeros with a j pointer while shifting elements and filling zeros.

Move zeros to the end of the array in place by using a zero index to place non-zero elements, then fill the rest with zeros, preserving order.

Walk through the pseudocode for brute force approach to the substring without repeating characters, detailing left and right pointers and a seen characters map, and hinting at sliding window optimization.

Apply the sliding window approach with two pointers and a last-seen map to find the longest substring without repeating characters. Use max to adjust the left boundary.

Walks through a sliding window approach to find the longest substring without repeating characters, using a seen characters map to update the left bound and track the maximum length.

Implement the longest palindrome using bottom-up dynamic programming with an is_palindrome matrix. Use end and start indices to build palindromes from smaller substrings.

Walk through a brute force approach with pseudocode, implementing find first and find last in an array using forward and backward loops, and analyze big o time and space complexity.

Apply binary search on a sorted array to find first (leftmost) occurrence of the target, then locate the last occurrence by narrowing the search span with left and right pointers.

Walk through a pseudocode binary search using two pointers to find the first and last occurrences of a target in a sorted array, detailing left, right, and mid computations.

Explore a two-pointer and binary search approach to locate the last occurrence of a target in a sorted array, using left, right, and mid pointers with constant space.

Explore the first bad version problem with a brute force linear search using the is bad version method to locate the first bad version and discuss time and space complexity.

Use the optimal solution by leveraging isBadVersion to locate the first bad version, halving the search span via the middle and updating left and right pointers until L equals R.

Walk through a binary search to find the first bad version using a mock isBadVersion API, narrowing with left and right pointers for log n time and constant space.

Implement a frequency map to count each input number, then identify the element whose frequency exceeds half the input size and return it as the majority element.

Walk through a pseudocode brute-force prime check using nested loops, showing how 2 and 3 are primes and 4 is not, and analyze time complexity O(n^2) with O(1) space.

Apply the sieve truthiness algorithm to mark non-primes by eliminating multiples of each prime from two to sqrt(n), using an isprime array. Count remaining true values to determine primes.

Demonstrates the Sieve of Eratosthenes to identify primes up to 34 by marking multiples. Explains prime validation, square-root stopping, and a practical code walkthrough.

Implement count primes with a sieve up to n, initializing isprime, marking 0 and 1 as non-prime, using sqrt(n) optimization, and counting true entries.