Customer Signer Screening
Reported by candidates from State Farm's online assessment. Pattern, common pitfall, and the honest play if you blank under the timer.
State Farm reported this one in October 2026, and the input size is the whole story. With up to 100000 customers, you can't afford to rescan a condition's allowed list for every row in a sloppy way. It's a filtering problem dressed up as a business rule: check each customer against every condition, output one string per row in the original order. The pattern is hash-table lookups. If the OA lands in your inbox this week, this is a clean one to get right fast. StealthCoder sits in the background as a safety net if you blank mid-assessment.
The problem
You are given customer records customers and signer rules conditions. Every customer row has the same width. customers[i][0] is a unique customer identifier, and the remaining columns are attributes. A condition has the form [columnIndex, allowedValue1, allowedValue2,...]. Its decimal columnIndex refers to an attribute column, and the customer satisfies that condition when its value in that column exactly matches at least one listed allowed value. A customer is a signer only when every condition is satisfied. Comparisons are case-sensitive. If conditions is empty, every customer is a signer. Return one string per customer in the original input order. Use customerId:SIGNER for a signer and customerId:NOT_SIGNER otherwise. Function screenCustomerSigners(customers: String[][], conditions: String[][]) → String[] Examples Example 1 customers = [["c01","CA","active"],["c02","NY","active"],["c03","CA","paused"]] conditions = [["1","CA"],["2","active"]] return = ["c01:SIGNER","c02:NOT_SIGNER","c03:NOT_SIGNER"] Only c01 has an allowed value in both tested columns. Each customer still receives one output row. Example 2 customers = [["a","gold","online"],["b","silver","branch"],["c","bronze","online"]] conditions = [["1","gold","silver"],["2","online","branch"]] return = ["a:SIGNER","b:SIGNER","c:NOT_SIGNER"] The first condition accepts two values. Customers a and b satisfy every condition, while c fails the first. Example 3 customers = [["left","pending"],["right","closed"]] conditions = [] return = ["left:SIGNER","right:SIGNER"] With no conditions, every customer satisfies the complete (empty) condition set. Constraints 1 <= customers.length <= 100000. 2 <= customers[i].length <= 20, and every customer row has the same length. Customer identifiers are unique. 0 <= conditions.length < customers[i].length. Each condition contains a decimal column index followed by 1 to 20 distinct allowed values. Condition column indices are distinct and lie between 1 and customers[i].length - 1. Every identifier, attribute, and allowed value contains 1 to 30 ASCII letters, digits, underscores, or hyphens.
Reported by candidates. Source: FastPrep
Pattern and pitfall
The trick is preprocessing. Parse each condition once: convert the column index string to an int and load the allowed values into a hash set. Then for each customer, loop over the conditions and check set membership by column. That's O(1) per check, so total work is roughly customers times conditions, which is at most 100000 times 19. Early exit on the first failed condition. The pitfalls are small but real. The column index arrives as a string, so parse it. Comparisons are case-sensitive, so don't lowercase anything. Empty conditions means everyone is a signer, which a plain loop handles for free. Keep output in input order and format it exactly as id:SIGNER or id:NOT_SIGNER. Don't sort or regroup. If you freeze on the format details during the live OA, StealthCoder is the hedge that reads the problem and hands you the working structure.
StealthCoder is the hedge for the one pattern you didn't drill. It runs invisibly during the screen share.
You can drill Customer Signer Screening 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. If you're reading this with an OA window open, you're who this was built for.
Get StealthCoderYou've seen the question.
Make sure you actually pass State Farm's OA.
State Farm reuses patterns across OAs. If you're reading this with an OA window open, you're who this was built for. Works on HackerRank, CodeSignal, CoderPad, and Karat.
Customer Signer Screening FAQ
How hard is Customer Signer Screening really?+
Easy to low-medium. There's no clever algorithm. It's careful parsing plus set lookups. Most failures come from forgetting to convert the column index from a string or botching the output format, not from the logic itself.
What's the trick to avoid brute force here?+
Build a hash set of allowed values per condition once, up front. Then each customer check is a constant-time membership test instead of scanning up to 20 allowed values. With 100000 rows, that preprocessing keeps things fast and clean.
What edge cases should I test?+
Test empty conditions, where every customer must be SIGNER. Test case differences like CA versus ca, which must not match. Test a customer failing only the last condition, and a single-condition input. Also confirm output order matches input order.
Do I need to sort or deduplicate anything?+
No. Customer IDs are unique and the output must follow the original input order. Allowed values are already distinct. Just iterate the customers in order and append one result string per row.
How do I prepare for this in 48 hours?+
Practice parsing string arrays into typed structures, building hash sets, and doing early-exit checks across rows. Write this exact function once from scratch. Then skim a few hash-table filtering problems so the pattern feels automatic on test day.