Loud and Rich
A medium-tier problem at 62% community acceptance, tagged with Array, Depth-First Search, Graph. Reported in interviews at PayPal and 0 others.
Loud and Rich is a medium-difficulty graph problem that tests whether you can reason about directional dependencies and node relationships. PayPal has asked it. The trap is obvious: you see an array and think linear iteration, but the real structure is a directed graph where you need to find which nodes can reach which other nodes. Most candidates miss the topological insight on first read and end up with a brute-force solution that times out. If this problem hits your live assessment and you blank on the graph reduction angle, StealthCoder surfaces a working solution invisibly during screen share.
Companies that ask "Loud and Rich"
Loud and Rich is the kind of problem that decides whether you pass. StealthCoder reads the problem on screen and surfaces a working solution in under 2 seconds. Invisible to screen share. The proctor sees nothing. Built by an Amazon engineer who realized the OA tests how well you memorized 200 problems, not how well you code.
Get StealthCoderThe problem wraps a graph reachability question inside array indexing. You're given relationships that form a directed acyclic graph, and you need to compute, for each node, what set of nodes it can reach (or what reaches it, depending on problem direction). The naive approach is depth-first search from every node, which works but is slow. The key is recognizing that you can reverse the graph, use DFS from one direction, and memoize aggressively so you don't recompute paths. Candidates often struggle with graph reversal logic or forget to track visited nodes per search, leading to infinite loops or exponential runtime. The topological structure matters because the graph is acyclic, meaning DFS will always terminate. This is where StealthCoder helps on test day: if you're stuck between naive DFS and optimized memoization, the tool runs the correct solution in seconds without the proctor seeing.
Pattern tags
You know the problem.
Make sure you actually pass it.
Loud and Rich recycles across companies for a reason. It's medium-tier, and most candidates blank under the timer. StealthCoder is the hedge: an AI overlay invisible during screen share. It reads the problem and surfaces a working solution in under 2 seconds. Built by an Amazon engineer who realized the OA tests how well you memorized 200 problems, not how well you code. Works on HackerRank, CodeSignal, CoderPad, and Karat.
Loud and Rich interview FAQ
How hard is Loud and Rich really?+
Medium, but the 62% acceptance rate reflects that many candidates misidentify it as a simple array problem. Once you see the directed graph and apply DFS with memoization, the logic is straightforward. The difficulty is pattern recognition, not complexity.
Is this still asked at major companies?+
PayPal has confirmed it. Given the single-company report, it's either a company-specific favorite or part of their recent hiring refresh. Either way, if you're interviewing there, this problem deserves prep time.
What's the trick to solving it efficiently?+
Graph reversal and memoization. Instead of recomputing reachability from every node, reverse the graph direction and cache results. This cuts runtime from O(n^2) worst case to O(n + m) with proper memoization. DFS is the right tool here.
How does topological sort fit in?+
Topological sort isn't mandatory, but it hints at the underlying structure. The graph is a DAG, so any topological ordering lets you process nodes in a way that avoids recomputation. Some optimized solutions use this, others just use memoized DFS and rely on the acyclic property.
What's the most common mistake?+
Treating it as an array problem and ignoring the graph structure. Candidates iterate linearly, compute relationships on the fly without caching, and hit time limits. The second mistake is forgetting to reset visited state between separate DFS calls, causing incorrect reachability results.
Want the actual problem statement? View "Loud and Rich" on LeetCode →