Coding Questions 2025 - Interview Problems with Solutions

Coding Questions - Complete Problem Set

Practice coding interview questions for fintech/payments companies. Focus on transaction processing and scalable systems.

Fintech Focus

Fintech companies value: Transaction processing, Fraud detection thinking, Scalable systems, Clean secure code.

Arrays & Strings

1. Two Sum

def two_sum(nums, target):
    seen = {}
    for i, num in enumerate(nums):
        complement = target - num
        if complement in seen:
            return [seen[complement], i]
        seen[num] = i
    return []

2. Valid Parentheses

def is_valid(s):
    stack = []
    mapping = {')': '(', '}': '{', ']': '['}
    for char in s:
        if char in mapping:
            top = stack.pop() if stack else '#'
            if mapping[char] != top:
                return False
        else:
            stack.append(char)
    return not stack

3. Transaction Validation

def validate_transaction(transactions, daily_limit):
    """
    Validate transactions against daily limit
    """
    daily_totals = {}
    valid = []

    for trans in transactions:
        date = trans['date']
        amount = trans['amount']

        if date not in daily_totals:
            daily_totals[date] = 0

        if daily_totals[date] + amount <= daily_limit:
            daily_totals[date] += amount
            valid.append(trans)

    return valid

4. Rate Limiter

import time
from collections import defaultdict

class RateLimiter:
    def __init__(self, max_requests, window_seconds):
        self.max_requests = max_requests
        self.window_seconds = window_seconds
        self.requests = defaultdict(list)

    def is_allowed(self, user_id):
        current_time = time.time()
        window_start = current_time - self.window_seconds

        self.requests[user_id] = [
            t for t in self.requests[user_id] if t > window_start
        ]

        if len(self.requests[user_id]) < self.max_requests:
            self.requests[user_id].append(current_time)
            return True
        return False

5. LRU Cache

from collections import OrderedDict

class LRUCache:
    def __init__(self, capacity):
        self.cache = OrderedDict()
        self.capacity = capacity

    def get(self, key):
        if key not in self.cache:
            return -1
        self.cache.move_to_end(key)
        return self.cache[key]

    def put(self, key, value):
        if key in self.cache:
            self.cache.move_to_end(key)
        self.cache[key] = value
        if len(self.cache) > self.capacity:
            self.cache.popitem(last=False)

Dynamic Programming

6. Coin Change

def coin_change(coins, amount):
    dp = [float('inf')] * (amount + 1)
    dp[0] = 0
    for i in range(1, amount + 1):
        for coin in coins:
            if coin <= i:
                dp[i] = min(dp[i], dp[i - coin] + 1)
    return dp[amount] if dp[amount] != float('inf') else -1

7. Maximum Subarray

def max_subarray(nums):
    max_sum = current_sum = nums[0]
    for num in nums[1:]:
        current_sum = max(num, current_sum + num)
        max_sum = max(max_sum, current_sum)
    return max_sum

Trees & Graphs

8. Binary Tree Level Order

from collections import deque

def level_order(root):
    if not root:
        return []
    result = []
    queue = deque([root])
    while queue:
        level = []
        for _ in range(len(queue)):
            node = queue.popleft()
            level.append(node.val)
            if node.left:
                queue.append(node.left)
            if node.right:
                queue.append(node.right)
        result.append(level)
    return result

Related Resources

Interview Experience

Real interview experiences.

Preparation Guide

Complete preparation strategy.

---

Master payment system concepts!

Last updated: January 2026