Team A High-Severity Transfer Hashes
Reported by candidates from Chainalysis's online assessment. Pattern, common pitfall, and the honest play if you blank under the timer.
The Chainalysis OA reported in March 2025 hands you four parallel arrays and asks for the transaction hashes where the team is exactly "Team A", the search type is exactly "transfer", and severity is exactly "high". It's a filter problem, not a puzzle. The catch is in the small print: keep stream order and keep duplicate hashes. If you've seen it, it takes five minutes. If you blank under the clock, StealthCoder is the invisible safety net running during the live OA. Don't overthink this one.
The problem
Four parallel arrays describe each log's team, search type, severity, and transaction hash. Return the transaction hash of every log whose team is exactly Team A, search type is exactly transfer, and severity is exactly high. Preserve stream order and duplicate hashes. Function teamAHighSeverityTransferHashes(teams: String[], searchTypes: String[], severities: String[], transactionHashes: String[]) → String[] Examples Example 1 teams = ["Team A","Team A","Team B"] searchTypes = ["transfer","address","transfer"] severities = ["high","high","high"] transactionHashes = ["0xaa","0xbb","0xcc"] return = ["0xaa"] Only the first log satisfies all three predicates. Example 2 teams = ["Team A","Team A"] searchTypes = ["transfer","transfer"] severities = ["high","high"] transactionHashes = ["0x1","0x1"] return = ["0x1","0x1"] Distinct qualifying logs retain duplicate hashes. Constraints All arrays have the same length from 0 through 100000. Every value is a non-empty ASCII string.
Reported by candidates. Source: FastPrep
Pattern and pitfall
The pattern is a single linear pass over the arrays. Loop index i from 0 to n-1, check teams[i], searchTypes[i] and severities[i] against the three literals, and if all match, append transactionHashes[i] to the result. That's O(n) time, and n tops out at 100000, so nothing fancy is needed. The pitfalls are all about the wording. Use exact string equality, not contains or case-insensitive matching, so "Team AB" or "High" must not pass. Don't put hashes in a set, because Example 2 returns "0x1" twice. Don't sort either. Handle the empty-array case by returning an empty list. In Java, use.equals, not ==. If you freeze on a trivial detail like that mid-assessment, StealthCoder can surface the loop while you stay calm and finish the rest.
The honest play: practice the pattern, and have StealthCoder ready for the one you didn't see coming.
You can drill Team A High-Severity Transfer Hashes cold, or you can hedge it. StealthCoder runs invisibly during screen share and surfaces a working solution in under 2 seconds. The proctor sees the IDE. They don't see what's behind it. Built for the candidate who saw this exact problem leak two days before his OA and wondered if anyone had a play.
Get StealthCoderRelated leaked OAs
You've seen the question.
Make sure you actually pass Chainalysis's OA.
Chainalysis reuses patterns across OAs. Built for the candidate who saw this exact problem leak two days before his OA and wondered if anyone had a play. Works on HackerRank, CodeSignal, CoderPad, and Karat.
Team A High-Severity Transfer Hashes FAQ
How hard is the Chainalysis Team A high-severity transfer hashes question really?+
It's easy. One loop, three string comparisons, one output list. The only way to miss it is by deduplicating, sorting, or using loose matching. Read the examples, especially the duplicate one, and you're done in a few minutes.
What's the trick in this problem?+
There isn't an algorithmic trick. The trick is following the spec literally. Exact string equality on all three fields, preserve input order, and keep duplicate hashes. Those three rules are what the examples test.
Should I use a hash set to dedupe the hashes?+
No. Example 2 explicitly returns "0x1" twice because two distinct logs qualify. Deduping would give the wrong answer. Just append every matching hash to a list in the order you scan.
What's the time complexity and does 100000 matter?+
O(n) time and O(k) extra space for k matches. With n up to 100000, a single pass is trivially fast. Avoid anything quadratic, like repeated list searches or nested loops over the arrays.
How do I prepare for this in 48 hours?+
Practice array filtering with parallel arrays in your chosen language. Confirm string equality syntax, handle empty input, and return a correctly typed list. Then spend the rest of your time on harder OA patterns like hash maps and sliding window.