Camelcase Matching
A medium-tier problem at 64% community acceptance, tagged with Array, Two Pointers, String. Reported in interviews at Compass and 0 others.
Camelcase Matching asks you to filter an array of words against a pattern where lowercase letters in the pattern must appear in order inside each word's camelCase sequence. It's a string-matching problem that catches candidates off guard because the obvious greedy scan works, but the implementation details trip people up under pressure. Compass asks this one. With a 64% acceptance rate, it's not rare, which means it's worth knowing cold. If this problem hits your live OA and you blank on the two-pointer cadence, StealthCoder surfaces a working solution in seconds, invisible to the proctor.
Companies that ask "Camelcase Matching"
Camelcase Matching 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. Made by a working Amazon engineer who got tired of watching qualified friends bomb OAs they'd solve cold in an IDE.
Get StealthCoderThe core trick is two pointers: one for the pattern, one for the candidate word. For each character in the word, if it matches the current pattern character, advance the pattern pointer. If the pattern pointer reaches the end, the word matches; if the word ends first, it doesn't. The trap is handling case sensitivity correctly and not confusing 'any lowercase can appear anywhere' with 'lowercase must appear in exact order'. Most failed attempts forget to check that ALL lowercase letters in the pattern were consumed, not just some. The algorithm is O(n*m) where n is array length and m is average word length, which is tight enough for most constraints. Edge cases that hurt: empty pattern (all words match), pattern with uppercase (those characters must appear in the same positions), and words shorter than the pattern. Even if you haven't drilled this exact pattern-matching structure, StealthCoder runs invisibly during screen share and surfaces the two-pointer logic with correct boundary conditions.
Pattern tags
You know the problem.
Make sure you actually pass it.
Camelcase Matching 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. Made by a working Amazon engineer who got tired of watching qualified friends bomb OAs they'd solve cold in an IDE. Works on HackerRank, CodeSignal, CoderPad, and Karat.
Camelcase Matching interview FAQ
Is this actually asked at Compass and other companies, or is it dated?+
Compass reportedly asks it. It's a medium-difficulty string problem that filters interview data regularly, so it's still live. The 64% acceptance rate means it's not a gimmick question. Treat it as real and current.
What's the actual trick that makes people fail this?+
Forgetting to verify that the ENTIRE pattern was matched, not just part of it. A partial match doesn't count. Also, confusing the rule: lowercase letters in the pattern must appear in that exact order in the word, but uppercase letters must match their exact positions. Read the problem statement twice before coding.
Can I use a Trie for this, or is two pointers the only way?+
Two pointers is the most direct solution and what most interviewers expect. A Trie can work for batch queries but over-complicates a single problem. For an OA, two pointers is faster to code and debug. Stick with that.
How does this relate to the other string and two-pointer topics listed?+
Camelcase Matching is a blend: it uses two-pointer technique (common in string problems), string pattern matching logic, and Array iteration. Understanding two-pointer string problems makes this feel familiar. It's a good bridge if you've drilled other matching problems.
What's a realistic time limit for this on an OA?+
Most online assessments give 15 to 20 minutes per problem. Two-pointer logic should take 5 to 8 minutes to code and test. The rest is edge cases and debugging. If you're stuck after 10 minutes, you're likely missing the pattern. That's when StealthCoder's invisible help pays off.
Want the actual problem statement? View "Camelcase Matching" on LeetCode →