Skip to main content

Plaid Coding Interview Questions

100 Plaid coding interview problems with full optimal solutions — 31 easy, 50 medium, 19 hard. Every problem ships with multiple approaches (brute-force first, then the optimal), complexity tables for each, company-specific tips on what an Plaid interviewer values, and a FAQ section.

  • #1easyfrequently asked

    1. Two Sum

    Given an array of integers and a target, return indices of two numbers that sum to the target. Plaid asks this as a warm-up before harder ETL problems to verify you reach for a hash map rather than the nested-loop instinct.

  • #2easyfrequently asked

    2. Valid Parentheses

    Determine if a string of brackets is balanced and properly nested. Plaid uses this to test stack reflexes before moving to nested JSON validation in webhook payloads.

  • #3easyfrequently asked

    3. Merge Two Sorted Lists

    Merge two sorted linked lists into one sorted list. Plaid asks this because merging two pre-sorted streams of transactions from different bank feeds is a daily operation on their ETL pipeline.

  • #4easyfrequently asked

    4. Remove Duplicates from Sorted Array

    In-place de-duplicate a sorted array and return the new length. Plaid asks this because de-duping near-duplicate transactions (same id, same amount, slight timestamp drift) is a daily reality on their ingestion pipeline.

  • #5easysometimes asked

    5. Remove Element

    Remove all occurrences of a value from an array in-place and return the new length. Plaid asks this because filtering out pending or void transactions before ETL is exactly the same shape.

  • #6easysometimes asked

    6. Search Insert Position

    Find the index where a target value should be inserted into a sorted array. Plaid asks this because finding the slot to splice a new ledger entry into a sorted journal is exactly this primitive.

  • #7easysometimes asked

    7. Plus One

    Increment a non-negative integer represented as an array of digits. Plaid asks this because incrementing big-integer balances (cents stored as digit arrays) without overflow is a real ledger primitive.

  • #8easyfrequently asked

    8. Merge Sorted Array

    Merge two sorted arrays in-place, where the first has extra trailing space to hold the second. Plaid asks this because merging a new batch of transactions into a pre-allocated buffer is a hot path in their ingestion code.

  • #9easysometimes asked

    9. Binary Tree Inorder Traversal

    Return the inorder traversal of a binary tree's node values. Plaid asks this as a tree-recursion baseline before harder traversal problems on transaction-category hierarchies.

  • #10easysometimes asked

    10. Same Tree

    Check if two binary trees are identical in structure and values. Plaid asks this as a baseline for harder tree-equality problems like checking whether two transaction-category snapshots match.

  • #11easysometimes asked

    11. Symmetric Tree

    Check whether a binary tree is a mirror of itself. Plaid asks this to test mirrored-recursion fluency before harder graph-symmetry problems.

  • #12easysometimes asked

    12. Maximum Depth of Binary Tree

    Return the maximum depth of a binary tree. Plaid asks this as a baseline for harder tree-depth problems on category hierarchies of varying depths from different financial institutions.

  • #13easysometimes asked

    13. Balanced Binary Tree

    Determine if a binary tree is height-balanced. Plaid asks this because their internal category trees must stay balanced for predictable lookup latency — and detecting imbalance is the prerequisite for triggering a rebuild.

  • #14easysometimes asked

    14. Minimum Depth of Binary Tree

    Return the minimum depth of a binary tree — the shortest root-to-leaf path. Plaid asks this because finding the nearest leaf in a category tree is exactly how they pick the shallowest classification for new transactions.

  • #15easyrarely asked

    15. Pascal's Triangle

    Generate the first numRows of Pascal's triangle. Plaid asks this as a DP-warm-up that exercises the 'each row depends on the previous' pattern used in their rolling-window financial aggregations.

  • #16easyfrequently asked

    16. Best Time to Buy and Sell Stock

    Find the maximum profit from buying and selling a stock once. Plaid asks this because computing max-drawdown style metrics over a price series is a familiar shape for their balance-history endpoints.

  • #17easysometimes asked

    17. Valid Palindrome

    Determine if a string is a palindrome after removing non-alphanumerics and lowercasing. Plaid asks this as a string-normalization warm-up before harder merchant-name canonicalization problems.

  • #18easysometimes asked

    18. Single Number

    Find the number that appears exactly once in an array where every other number appears twice. Plaid asks this because finding the un-matched ledger entry in a reconciliation pass has exactly this shape.

  • #19easysometimes asked

    19. Linked List Cycle

    Detect whether a linked list has a cycle. Plaid asks this as a baseline before harder graph-cycle problems on account-link chains and OAuth refresh-token graphs.

  • #20easyfrequently asked

    20. Min Stack

    Design a stack that supports push, pop, top, and retrieving the minimum element in constant time. Plaid asks this because tracking the running minimum balance over a transaction stream needs exactly this primitive.

  • #21easysometimes asked

    21. Two Sum II - Input Array Is Sorted

    Given a sorted array, find two indices whose values sum to a target. Plaid asks this to verify you exploit sortedness — same shape as finding two transactions on a sorted balance-history that net to a target gap.

  • #22easysometimes asked

    22. Majority Element

    Find the element that appears more than n/2 times in an array. Plaid asks this because identifying the dominant merchant category across a user's transactions has the same shape.

  • #23easysometimes asked

    23. Rotate Array

    Rotate an array to the right by k steps in-place. Plaid asks this because shifting a circular buffer of recent transactions by a rotation amount has the same shape.

  • #24easyrarely asked

    24. Reverse Bits

    Reverse the bits of a 32-bit unsigned integer. Plaid asks this as a bitwise-fluency check before harder hash-collision and idempotency-key problems.

  • #25easyrarely asked

    25. Number of 1 Bits

    Count the number of set bits in an unsigned integer. Plaid asks this as a bitwise warm-up before harder bitmask problems on account-feature flags.

  • #26easyrarely asked

    26. Happy Number

    Determine whether a number eventually reaches 1 under repeated digit-square-sum, or cycles forever. Plaid asks this because cycle detection on transformation sequences is the same algorithm as detecting OAuth refresh-token loops.

  • #27easysometimes asked

    27. Isomorphic Strings

    Determine if two strings are isomorphic — one character maps to one other character consistently. Plaid asks this because tokenizing merchant strings under a consistent mapping is the same primitive.

  • #28easyfrequently asked

    28. Reverse Linked List

    Reverse a singly-linked list. Plaid asks this as a pointer-juggling baseline before harder list problems on transaction history sequences.

  • #29easyfrequently asked

    29. Contains Duplicate

    Determine if any value appears at least twice in an array. Plaid asks this because detecting duplicate webhook deliveries or duplicate idempotency keys is exactly this primitive.

  • #30easysometimes asked

    30. Invert Binary Tree

    Invert (mirror) a binary tree. Plaid asks this as a recursion warm-up before harder category-tree transformations.

  • #31mediumfrequently asked

    31. Add Two Numbers

    Add two numbers represented as reverse-order linked lists. Plaid asks this because adding two arbitrary-precision balances digit-by-digit with carry is exactly how their ledger code handles cents that overflow JS Number precision.

  • #33mediumsometimes asked

    33. Longest Palindromic Substring

    Find the longest palindromic substring. Plaid asks this as a 'expand around center' fluency check before harder string-canonicalization problems on merchant names.

  • #34mediumsometimes asked

    34. Container With Most Water

    Find two lines that, together with the x-axis, form the container with the most water. Plaid asks this as a two-pointer optimization classic before harder window problems on balance-history charts.

  • #35mediumfrequently asked

    35. 3Sum

    Find all unique triplets that sum to zero. Plaid asks this because three-way reconciliation across a debit, a credit, and a fee is exactly this primitive — find three rows that net to zero.

  • #36mediumrarely asked

    36. Letter Combinations of a Phone Number

    Generate all letter combinations that a phone-number string could represent. Plaid asks this as a backtracking warm-up before harder combinatorial problems on transaction-tag suggestions.

  • #37mediumsometimes asked

    37. Remove Nth Node From End of List

    Remove the nth node from the end of a linked list in one pass. Plaid asks this as a two-pointer baseline before harder windowed-removal problems on transaction-history lists.

  • #38mediumsometimes asked

    38. Generate Parentheses

    Generate all combinations of n well-formed parentheses. Plaid asks this as a backtracking pattern problem before harder nested-JSON validation work on webhook payloads.

  • #39mediumsometimes asked

    39. Swap Nodes in Pairs

    Swap every two adjacent nodes in a linked list. Plaid asks this to verify pointer-juggling fluency before harder list-restructuring problems on chronological transaction sequences.

  • #40mediumrarely asked

    40. Next Permutation

    Rearrange numbers into the lexicographically next greater permutation. Plaid asks this because deterministic enumeration of equivalent reorderings is the same primitive they use when retrying batch ETL jobs in a fixed cycle.

  • #41mediumfrequently asked

    41. Search in Rotated Sorted Array

    Search for a target in a sorted array that has been rotated. Plaid asks this because querying a circular buffer of transaction timestamps that wraps around a clock pivot is the same primitive.

  • #43mediumsometimes asked

    43. Valid Sudoku

    Determine if a 9x9 Sudoku board is valid (without solving it). Plaid asks this as a constraint-validation primitive — the same shape as their multi-constraint webhook payload validator.

  • #44mediumsometimes asked

    44. Combination Sum

    Find all unique combinations of candidates that sum to a target, where the same number may be chosen unlimited times. Plaid asks this because finding all ways to assemble a target balance from a fixed denomination set is the same primitive.

  • #45mediumsometimes asked

    45. Permutations

    Return all possible permutations of distinct integers. Plaid asks this as a backtracking warm-up before harder ordering problems on transaction-processing schedules.

  • #46mediumsometimes asked

    46. Rotate Image

    Rotate an NxN matrix 90 degrees clockwise in place. Plaid asks this because in-place 2D transforms are the same shape as their column-major to row-major balance-history transposition for charts.

  • #47mediumfrequently asked

    47. Group Anagrams

    Group anagrams together from an array of strings. Plaid asks this because grouping merchant names that share the same character profile (after normalization) is a daily reality on their merchant-deduplication pipeline.

  • #48mediumfrequently asked

    48. Maximum Subarray

    Find the contiguous subarray with the largest sum. Plaid asks this because finding the highest-net-deposit window in a transaction series uses exactly this primitive — Kadane's algorithm.

  • #49mediumsometimes asked

    49. Jump Game

    Determine if you can reach the last index of an array where each value is your max jump length. Plaid asks this as a greedy-baseline problem before harder reachability questions on retry-graph traversal.

  • #50mediumfrequently asked

    50. Merge Intervals

    Merge overlapping intervals. Plaid asks this because consolidating overlapping batch-windows (when ETL retries cover overlapping time ranges) is exactly this primitive.

  • #51mediumsometimes asked

    51. Unique Paths

    Count the number of unique paths from top-left to bottom-right of an m x n grid, moving only right or down. Plaid asks this as a DP warm-up before harder grid-DP problems on transaction-state machines.

  • #52mediumsometimes asked

    52. Minimum Path Sum

    Find the path from top-left to bottom-right with the smallest sum. Plaid asks this as a grid DP variation, mapping cleanly to lowest-cost routing in their multi-hop payment-rail graph.

  • #53mediumsometimes asked

    53. Simplify Path

    Simplify a Unix-style absolute file path. Plaid asks this as a stack warm-up before harder hierarchical-category-tree normalization problems.

  • #54mediumfrequently asked

    54. Edit Distance

    Find the minimum operations to convert one string into another (insert, delete, replace). Plaid asks this because fuzzy merchant matching uses edit distance to collapse variants like 'STARBUCKS #234' and 'Starbucks #234A' into one canonical merchant.

  • #55mediumsometimes asked

    55. Set Matrix Zeroes

    If an element in an MxN matrix is 0, zero out its entire row and column in-place. Plaid asks this because invalidating a row+column band of a cached pivot table when one cell flips is exactly this primitive.

  • #56mediumsometimes asked

    56. Search a 2D Matrix

    Search for a target in a row-sorted matrix where each row's first element is greater than the previous row's last. Plaid asks this as a binary-search-on-flattened-grid problem before harder bank-feed lookup questions.

  • #57mediumsometimes asked

    57. Sort Colors

    Sort an array of 0s, 1s, and 2s in place in one pass. Plaid asks this because partitioning a transaction stream into 'pending', 'cleared', 'failed' buckets uses exactly this Dutch National Flag primitive.

  • #58hardfrequently asked

    58. Minimum Window Substring

    Find the smallest window in a string containing all characters of a pattern. Plaid asks this because finding the smallest time window covering all required transaction-types in a feed (e.g., debit, credit, fee) is the same primitive.

  • #59mediumsometimes asked

    59. Subsets

    Return all possible subsets (the power set) of a distinct-integer array. Plaid asks this as a combinatorial-generation warm-up before harder subset-sum reconciliation problems.

  • #60mediumsometimes asked

    60. Word Search

    Determine if a word exists in a 2D grid by traversing adjacent cells. Plaid asks this as a DFS-on-grid baseline before harder graph-traversal problems on account-link graphs.

  • #61mediumrarely asked

    61. Remove Duplicates from Sorted Array II

    Remove duplicates in-place such that each element appears at most twice. Plaid asks this as a two-pointer variant — exactly the shape they use to enforce 'at most 2 retries per transaction in the same minute' logs.

  • #62mediumrarely asked

    62. Search in Rotated Sorted Array II

    Search a rotated sorted array that may contain duplicates. Plaid asks this as a binary-search-with-ambiguity problem — exactly the shape they face when a circular log has duplicate-event timestamps.

  • #63mediumrarely asked

    63. Remove Duplicates from Sorted List II

    Delete all nodes in a sorted linked list that have duplicate values, keeping only unique values. Plaid asks this because removing transactions that have any duplicate occurrences (not keeping one) is a stricter dedup needed for audit logs.

  • #64mediumrarely asked

    64. Partition List

    Partition a linked list around a value x. Plaid asks this because partitioning a transaction stream into 'below threshold' and 'above threshold' is the same primitive.

  • #65mediumsometimes asked

    65. Decode Ways

    Count the number of ways to decode a digit string where 'A'=1 ... 'Z'=26. Plaid asks this as a DP warm-up before harder parser-state problems on variable-length transaction-code formats.

  • #66mediumsometimes asked

    66. Reverse Linked List II

    Reverse a sublist of a linked list between positions left and right. Plaid asks this as a pointer-juggling problem — exactly the shape they use when restoring a corrupted segment of a transaction-history list from a backup.

  • #67mediumrarely asked

    67. Restore IP Addresses

    Generate all valid IP addresses from a digit string. Plaid asks this as a backtracking warm-up — the same shape they use when parsing variable-length transaction codes split across delimiters.

  • #68mediumrarely asked

    68. Unique Binary Search Trees II

    Generate all structurally unique BSTs with n nodes. Plaid asks this as a recursion + memoization warm-up before harder tree-construction problems on category-tree variants.

  • #69mediumfrequently asked

    69. Validate Binary Search Tree

    Determine if a binary tree is a valid BST. Plaid asks this because validating that a freshly-built merchant-category tree obeys its strict-ordering invariant is the same primitive — bugs in the invariant cause cascading mis-classification later.

  • #71mediumsometimes asked

    71. Binary Tree Zigzag Level Order Traversal

    Return the zigzag level order traversal of a tree. Plaid asks this as a BFS variant — exactly the shape they use when alternating left-to-right vs right-to-left iteration over partitioned ledger shards.

  • #73easysometimes asked

    73. Convert Sorted Array to Binary Search Tree

    Convert a sorted array into a height-balanced BST. Plaid asks this because indexing a sorted financial-category list into a balanced lookup tree for O(log n) range queries is exactly the same primitive.

  • #74mediumfrequently asked

    74. LRU Cache

    Design an LRU cache with O(1) get and put. Plaid asks this because their idempotency-key store and recent-transactions cache both need O(1) bounded-memory LRU semantics.

  • #75mediumfrequently asked

    75. Word Break

    Determine if a string can be segmented into a sequence of dictionary words. Plaid asks this because tokenizing a merchant string into known sub-tokens (e.g., 'AMZNMKTPLACE' -> 'AMZN' + 'MKT' + 'PLACE') is the same primitive.

  • #76mediumsometimes asked

    76. Copy List with Random Pointer

    Deep copy a linked list where each node has a random pointer to any other node. Plaid asks this because cloning an entity graph with cross-references (transactions pointing to merchants pointing to categories) uses the same pattern.

  • #77mediumfrequently asked

    77. Clone Graph

    Deep copy a connected undirected graph. Plaid asks this because their account-link graph (user -> bank -> account -> transaction) is exactly this kind of cyclic reference structure that must be cloneable for snapshot tests.

  • #78mediumsometimes asked

    78. Sort List

    Sort a linked list in O(n log n) time. Plaid asks this because sorting a stream of transactions that arrived as a linked list (from a bank-feed batch) before merging into the master ledger is exactly this primitive.

  • #79mediumsometimes asked

    79. Find Minimum in Rotated Sorted Array

    Find the minimum element in a rotated sorted array. Plaid asks this because finding the rotation pivot (e.g., the day a circular billing window restarts) is the same primitive.

  • #80mediumrarely asked

    80. Find Peak Element

    Find a peak element in an array (one whose value is strictly greater than its neighbors). Plaid asks this as a binary-search-on-properties problem — exactly the shape they use to find traffic peaks in a time-bucketed transaction-rate series.

  • #81hardsometimes asked

    81. Median of Two Sorted Arrays

    Find the median of two sorted arrays in O(log(min(m,n))). Plaid asks this as a binary-search-on-partitions problem because computing percentile across two sharded ledgers without merging them is the same primitive.

  • #82hardsometimes asked

    82. Regular Expression Matching

    Implement regular expression matching with '.' and '*'. Plaid asks this because matching merchant-name patterns with wildcards is a recurring sub-problem in their pattern-based classification rules.

  • #83hardfrequently asked

    83. Merge k Sorted Lists

    Merge k sorted linked lists into one sorted list. Plaid asks this because merging k pre-sorted bank-feed streams into a unified ledger is exactly this primitive — it's their core ETL fan-in operation.

  • #84hardsometimes asked

    84. Reverse Nodes in k-Group

    Reverse the nodes of a linked list k at a time. Plaid asks this as an advanced pointer-juggling problem — the same shape they use when reordering chunks of a transaction-batch list during retry-coalescing.

  • #85hardrarely asked

    85. Substring with Concatenation of All Words

    Find all starting indices of substrings that are concatenations of every word in a given list (each used exactly once, any order). Plaid asks this as a multi-token sliding-window problem — exactly the shape they use to find required-feature sequences in a webhook batch.

  • #86hardrarely asked

    86. Longest Valid Parentheses

    Find the length of the longest valid parentheses substring. Plaid asks this as a stack-based scanning problem — the same shape they use to find the longest run of properly-paired JSON braces in a corrupted webhook payload.

  • #87hardsometimes asked

    87. First Missing Positive

    Find the smallest missing positive integer in O(n) time and O(1) space. Plaid asks this because finding the next available transaction-id in a partially-allocated id-pool is exactly this primitive.

  • #88hardfrequently asked

    88. Trapping Rain Water

    Compute how much water can be trapped between vertical bars. Plaid asks this as a two-pointer + running-max problem — the same shape they use to compute the cumulative un-allocated liquidity across a fluctuating balance series.

  • #89hardrarely asked

    89. Wildcard Matching

    Implement wildcard matching with '?' (single char) and '*' (any sequence). Plaid asks this because matching merchant patterns with arbitrary-length wildcards is part of their pattern-based category rules.

  • #90hardsometimes asked

    90. Jump Game II

    Find the minimum number of jumps to reach the last index. Plaid asks this as a BFS-as-greedy problem — the same shape as finding the minimum number of API-hops to reach a target endpoint across their bank-rail graph.

  • #91hardrarely asked

    91. N-Queens

    Place N queens on an NxN board such that no two attack each other; return all solutions. Plaid asks this as a backtracking classic before harder constraint-satisfaction problems.

  • #92mediumsometimes asked

    92. Insert Interval

    Insert a new interval into a sorted, non-overlapping list and merge if necessary. Plaid asks this because adding a new ETL-retry window to a sorted list of pre-existing windows is exactly this primitive.

  • #93hardrarely asked

    93. Text Justification

    Format text into fully justified lines of fixed width. Plaid asks this as a careful greedy + arithmetic problem — the same flavor of edge-case discipline they need when formatting tabular statement output for end users.

  • #94hardrarely asked

    94. Sudoku Solver

    Solve a 9x9 Sudoku in place. Plaid asks this as a backtracking + constraint-propagation problem — the same shape as their constraint-satisfaction engine that validates merchant-category assignments under multi-axis rules.

  • #95hardsometimes asked

    95. Largest Rectangle in Histogram

    Find the area of the largest rectangle in a histogram. Plaid asks this as a monotonic-stack problem — the same shape they use to find the longest sustained-throughput window in a transaction-rate histogram.

  • #96hardrarely asked

    96. Maximal Rectangle

    Find the largest all-1's rectangle in a binary matrix. Plaid asks this as a 'reduce-to-known-problem' classic — the maximal rectangle in a binary matrix reduces to multiple histogram problems.

  • #97hardsometimes asked

    97. Valid Number

    Determine if a string represents a valid number (with signs, decimals, exponents). Plaid asks this as a finite-state-machine problem — exactly the shape they need when parsing transaction amounts from heterogeneous bank-feed formats.

  • #98mediumsometimes asked

    98. Recover Binary Search Tree

    Two nodes in a BST have been swapped by mistake; recover the tree without changing structure. Plaid asks this because detecting and repairing two-row swap corruption in a sorted category tree (without rebuilding) is exactly this primitive.

  • #99hardsometimes asked

    99. Word Ladder

    Find the shortest transformation from beginWord to endWord, changing one letter at a time, where each intermediate is in the dictionary. Plaid asks this as a BFS-shortest-path problem — the same shape as finding the minimum-hop route across their bank-rail graph.

  • #100hardfrequently asked

    100. Serialize and Deserialize Binary Tree

    Design serialize/deserialize for a binary tree. Plaid asks this because their merchant-category tree must be snapshot-able for caching and idempotent replay — they need a stable, deterministic serialization that survives round trips.

Plaid Coding Interview Questions — Full Solutions — InterviewChamp.AI