Coding interview: perguntas para devs

+5

Leetcode 146. LRU Cache

Implement an LRUCache that supports O(1) average-time get(key) returning the value or -1 and put(key, value) which inserts or updates a key and, if capacity is exceeded, evicts the least-recently-used key. The core challenge is maintaining key-value storage together with recency ordering to enable constant-time access, updates, and eviction.

+3

Leetcode 253. Meeting Rooms II

Given a list of meeting time intervals, determine the minimum number of conference rooms required so that no meetings overlap. The core challenge is computing the maximum number of concurrent intervals (e.g., via sorting with a min-heap of end times or a sweep-line of start/end events).

+3

Leetcode 20. Valid Parentheses

Check whether a string of parentheses/brackets is valid by ensuring every closing bracket matches the most recent unmatched opening bracket and the types and nesting order are correct. This is typically solved by tracking openings (e.g., with a stack) and verifying matching pairs.

+2

Leetcode 981. Time Based Key-Value Store

Design a time-based key-value store that records multiple values per key with timestamps and returns the value whose timestamp is the largest <= the queried timestamp. With timestamps per key strictly increasing and up to 2e5 operations, the typical solution uses per-key ordered timestamp/value lists and binary search to find the floor timestamp efficiently.

+2

Leetcode 210. Course Schedule II

Given numCourses and prerequisite pairs, return any ordering of courses that satisfies all prerequisites or an empty array if impossible — this is essentially computing a topological sort of a directed graph and detecting cycles.

+2

Leetcode 200. Number of Islands

Count the number of islands (4-directionally connected components of '1's) in an m×n binary grid. This is a connected-components/flood-fill problem typically solved with DFS/BFS or Union-Find in O(mn) time (m,n ≤ 300).

+1

Leetcode 347. Top K Frequent Elements

Given an integer array and k, return the k most frequent elements — the core challenge is to count element frequencies and extract the top-k efficiently (better than O(n log n)), typically using a frequency map combined with a min-heap (O(n log k)) or bucket sort (O(n)).

+1

Leetcode 236. Lowest Common Ancestor of a Binary Tree

Given a binary tree and two nodes p and q, find their lowest common ancestor — the deepest node that has both p and q as descendants (a node can be a descendant of itself). The tree can be large (up to 2e5 nodes), nodes are unique and p and q are guaranteed to exist.

+1

Leetcode 124. Binary Tree Maximum Path Sum

Find the maximum sum of any non-empty connected path in a binary tree (nodes used at most once), where the path can start and end at any nodes and node values may be negative. You must account for single-node paths when all values are negative.

+1

Leetcode 207. Course Schedule

Given courses as nodes and prerequisite pairs as directed edges, determine whether the directed graph is acyclic — return true if a topological ordering exists (all courses can be completed), otherwise false if a cycle prevents completion.

Leetcode 88. Merge Sorted Array

Given two sorted arrays nums1 and nums2 and counts m and n (nums1 has length m+n with its last n slots free), merge the elements into nums1 in non-decreasing order in-place. Aim for an O(m + n) solution that uses the available buffer rather than returning a new array.

Design a File Search and Directory Traversal System

Design and implement a file search system that can traverse directory structures and locate files based on various criteria. The solution should incorporate object-oriented programming principles, support extensible filtering mechanisms, and be optimized for performance. Consider implementing algorithms like DFS or BFS for traversal, and discuss scalability considerations for adding new search filters and optimizations such as byte-level operations.

Leetcode 53. Maximum Subarray

Find the contiguous subarray within an integer array that yields the maximum possible sum and return that sum. This is typically solved in O(n) with Kadane's algorithm (with an alternative divide-and-conquer approach as a follow-up).

Leetcode 212. Word Search II

Given an m×n letter grid and a list of words, find all words that can be formed by sequentially adjacent (horizontal/vertical) non-repeating cells. The core challenge is efficiently searching many candidate words on the board using DFS/backtracking with prefix pruning (e.g., a Trie) to handle up to 12×12 boards and tens of thousands of words.

Leetcode 23. Merge k Sorted Lists

Leetcode 353. Design Snake Game

Simulate a Snake game on an m×n grid supporting move(direction): the snake advances, grows when it eats sequentially placed food (increasing score), and the game ends on collision with walls or the snake's own body. Candidates should track the snake body and occupied cells efficiently for frequent moves (e.g., deque + hash set) and handle food lookup and collision checks.

Leetcode 2050. Parallel Courses III

Given a DAG of course prerequisites where each course has a duration and any number of courses can run in parallel once prerequisites are satisfied, compute the minimum time to finish all courses. This is the classic longest-path/critical-path problem on a node-weighted DAG — compute each course's earliest completion time as max(completion times of prerequisites) + its duration.

Leetcode 62. Unique Paths

Count the number of distinct monotonic paths from the top-left to the bottom-right of an m×n grid when you may only move right or down. This is the classic lattice-path problem — the answer equals binomial coefficient C(m+n-2, m-1) (or can be computed with DP); m,n ≤ 100 and result ≤ 2·10^9.