Data Structures and Algorithms

Infer edge cases and the maximum feasible time complexity from an interview problem's constraints.

Construct a brute-force baseline and identify the operation that limits its performance.

Determine the time complexity of Java code containing sequential and nested loops.

Determine the time and auxiliary-space complexity of a recursive algorithm.

Select an appropriate Java collection using its operation costs, ordering behavior, duplicate handling, and amortized guarantees.

Justify an optimized algorithm using a correctness invariant and an explicit time-space trade-off.

Use a HashMap or HashSet to replace repeated searches with constant-average-time lookups.

Construct frequency tables to solve counting and grouping problems involving arrays or strings.

Use a prefix-sum array to answer repeated range-sum queries.

Transform a subarray-sum condition into a prefix-sum and hash-lookup problem.

Apply Kadane's algorithm to find an optimal contiguous subarray.

Apply opposite-direction pointers to a sorted-array problem.

Apply same-direction pointers to compact or partition an array in place.

Solve a fixed-size sliding-window aggregation problem.

Maintain counts while solving a variable-size sliding-window problem.

State the invariant that makes a two-pointer or sliding-window solution correct.

Distinguish problems suited to sliding windows from those requiring prefix sums or hashing.

Reverse a singly linked list iteratively without losing references.

Use slow and fast pointers to detect a linked-list cycle.

Use a dummy node to simplify a linked-list deletion or merge.

Use a monotonic stack to compute next-greater or next-smaller relationships.

Implement an overflow-safe boundary-search template in Java and adapt it to exact, first-position, or last-position queries.

Apply binary search to a monotonic answer space by defining a feasibility predicate.

Write Java comparators for multi-key ordering without subtraction-based overflow bugs.

Merge overlapping intervals after sorting by a justified key.

Solve an interval-scheduling problem using the earliest-finish-time rule and justify the rule with an exchange argument.

Implement recursive and iterative depth-first traversals of a binary tree.

Use an ArrayDeque to process a binary tree level by level.

Compute a tree result by combining values returned from child subtrees.

Validate a binary search tree by propagating legal value bounds.

Use a Java PriorityQueue to retain the k best candidates while scanning an input.

Represent an interview problem as a Java adjacency list by defining its vertices and edges.

Use breadth-first search to find shortest paths in an unweighted graph.

Use depth-first search to identify connected components.

Detect cycles in a directed graph using traversal states.

Produce a topological ordering for a dependency graph.

Apply Dijkstra's algorithm to a graph with nonnegative edge weights using a priority queue.

Model a backtracking search tree by defining its state, choices, base case, branching factor, and depth.

Generate all subsets while restoring mutable state correctly.

Generate permutations while preventing unintended element reuse and duplicate outputs.

Prune a combination-search tree using constraints and ordering.

Backtrack through a grid while marking and restoring visited cells correctly.

Define a dynamic-programming state whose parameters uniquely identify a subproblem.

Derive a recurrence and base cases from the decisions available in each state.

Implement the same recurrence using top-down memoization and bottom-up tabulation in Java.

Reduce dynamic-programming space when each state depends only on a bounded set of prior states.

Solve a one-dimensional decision problem using dynamic programming.

Solve a 0/1 knapsack or subset-sum variant using dynamic programming.

Solve a grid-based path or optimization problem using dynamic programming.

Solve a two-string alignment or matching problem using dynamic programming.

Classify an unfamiliar problem using its constraints and structural clues rather than keywords alone.

Present an approach aloud by stating assumptions, the key invariant, complexity, and a boundary-case dry run.

Complete a timed Easy-to-Medium coding interview using a structured workflow.

Diagnose a failed or slow solution as a recognition, reasoning, implementation, or testing error and record the diagnosis in a mistake log.

Apply a cold re-solve protocol to reimplement and verify a previously missed problem without prior code or hints.

Complete a timed mixed-topic Medium interview and produce a concise retrospective with specific follow-up actions.