Cracking the Coding Interview

Learn how to determine if a string is a permutation of a palindrome by analyzing character counts. Examples show ababa yields true, while abac yields false.

Count the frequency of each character and verify that all frequencies are even for even-length palindromes, or at most one odd frequency for odd-length palindromes, to form a palindrome.

Analyze the time and space complexity of a string frequency approach. Time complexity is O(n) and space complexity is O(1) with a hashmap storing at most 26 letters.

Learn to determine if a string can be permuted to form a palindrome by counting character frequencies with a hashmap and checking odd counts.

Implement an algorithm to find the kth to last element of a singly linked list, using examples where k=2 yields 5 and k=4 yields 3 to illustrate the approach.

Traverse the linked list from the head to determine its size, then find the kth last element using index = size - k + 1, revealing a two-pass brute-force approach.

Use the two-pointer technique to locate the target in a linked list by moving p1 k steps and advancing both pointers until p1 is null, yielding O(n) time.

Develop a two-pointer approach on a single linked list to return the 4th last element by moving the first pointer k steps, then advancing both until null, yielding p2's data.

Design a stack with a min() function that returns the current minimum, while push, pop, and min operate in 0(1) time.

Build a stack with a min() operation by using an auxiliary minStack to track the current minimum, enabling O(1) push, pop, and min.

Extend the actual stack to include a minStack, implement push, pop, and min(), with min() returning the top of minStack or Integer.MAX_VALUE when empty.

Learn to reverse a single linked list, turning one two three four five into five four three two one. Explore the problem statement and approach for coding interviews.

Practice reversing a linked list using an iterative approach that updates each node's next to its previous, while maintaining current, previous, and next pointers, with O(n) time and O(1) space.

Code the reversal of a singly linked list using current, previous, and next. Test with console input and a simple SingleLinkedList that inserts, prints, and reverses.

In the Cracking the Coding Interview course, practice a common interview problem: given a sorted array and a key, return the index of the first occurrence of that key.

Clarify the problem statement and write down the test cases, then proceed to the next lecture.

Identify test cases for a sorted array problem, including a five-element sorted example, an all-same element array, a combination of first two, and edge cases with sizes 1 and 2.

Identify a two-step approach to a problem: first brute force, then optimize to the maximum extent. Develop the optimized solution and proceed to the next lecture.

Perform a brute force left-to-right scan to find the first occurrence of a given element in a sorted array, then return its index with constant space.

Use binary search on a sorted array to find the first occurrence of a target, using left and right pointers and updating the result, with space complexity O(1).

Apply the optimised approach and write down the code on a white paper or in a text editor, then advance to the next lecture.

Implement a binary search to find the first occurrence of a target in a sorted array, updating the right pointer to middle minus one on a match, and test cases.

Explore counting the ways to climb n steps with hops of 1, 2, or 3, and implement a method to compute the total, a popular coding interview question.

Count the number of ways to climb a staircase with 1, 2, or 3 steps at a time, using n steps; illustrated with n = 3 yielding four paths.

Outline a recursive approach to counting ways to climb n steps with 1, 2, or 3 steps, using f(n)=f(n-1)+f(n-2)+f(n-3) with base cases f(0)=1 and f(n<0)=0, and highlight 3^n time.

Cache f(n) values in an array and reuse them for the recurrence f(n)=f(n-1)+f(n-2)+f(n-3), with negatives returning zero and f(0)=1, achieving O(n) time.

Explore how to compute the number of trailing zeros in n factorial using an algorithm, with examples like 5! = 120 (1 zero) and 10! (2 zeros).

Determine trailing zeros in n! by counting 5s, since 2s are abundant. Divide n by 5, 25, 125, and sum the quotients to get the zero count.

Learn to compute trailing zeros in factorials by counting factors of five and using a loop to accumulate the count, validating with simple tests.

Implement a method to find a fixed point in a sorted array of distinct integers, returning an index where the element equals its index. Observe 2 or 3.

Explore the brute force method to find an index where the array value equals the index in a sorted, distinct array, with O(n) time and O(1) space.

Apply binary search on a sorted distinct array to find an index where the element equals the index, narrowing to left or right half for O(log n) time.

Write test cases to validate the search approach, using scenarios where the target sits in the middle, left, or right, or is absent, returning 2, 1, 4, or -1.

Validate the algorithm with test cases, using middle element comparisons to index to prune left or right halves, confirming test cases pass before implementing the code.

Code the solution to find an index where the element equals the index by using a left and right pointer, evaluating the middle, and breaking on a match.

Transform a string or array of characters with whitespace-separated words into reverse word order using in-place operations, achieving O(1) space and O(1) time complexity.

Use a two-pointer strategy to reverse the full sentence, then reverse each word to restore order. Move start and end pointers to swap characters around spaces.