Array Questions at Deutsche Bank: What to Expect

Array questions dominate Deutsche Bank’s technical interviews, making up 16 of their 21 most frequent coding problems. This isn’t random. Arrays are the fundamental data structure for representing ordered data—core to financial data streams, time-series analysis, transaction records, and pricing models. Mastering them demonstrates you can handle the sequential, index-based data processing that underpins much of quantitative and systems work at the bank. If you want to pass their technical screen, array proficiency is non-negotiable.

What to Expect — Types of Problems

Deutsche Bank’s array problems generally fall into three practical categories. First, two-pointer techniques are essential for problems involving sorted data, pair sums, or in-place manipulations, like merging sorted arrays or removing duplicates. Second, sliding window patterns appear frequently for subarray problems, such as finding the maximum sum subarray of a fixed size or the smallest subarray with a sum greater than a target—scenarios directly analogous to analyzing rolling time windows in market data. Third, expect basic transformation and traversal questions, including rotations, rearrangements, and searches, which test your ability to manipulate indices accurately and efficiently under constraints. The problems are typically medium difficulty, focusing on clean implementation over obscure algorithms.

How to Prepare — Study Tips with One Code Example

Focus on pattern recognition, not memorization. Map each problem to a core technique (e.g., hash map for complement searches, prefix sum for range queries). Practice writing bug-free code under time pressure, paying special attention to edge cases like empty arrays, single elements, and integer overflow. Always discuss time and space complexity first.

A key pattern to master is the two-pointer swap for in-place operations. Here’s an example of moving all zeros to the end of an array while maintaining the relative order of non-zero elements.

def moveZeroes(nums):
    insert_pos = 0
    for i in range(len(nums)):
        if nums[i] != 0:
            nums[insert_pos], nums[i] = nums[i], nums[insert_pos]
            insert_pos += 1
    # Modification is in-place, no return needed

This approach uses a single pass with O(1) extra space, which is optimal. Practice this pattern until the pointer logic is automatic.

Recommended Practice Order

Tackle problems in this sequence to build competence efficiently:

1. Fundamentals: Start with basic traversal, resizing, and simple two-pointer problems (e.g., reverse an array, remove duplicates).
2. Sliding Window: Move to fixed and dynamic window problems to understand subarray computations.
3. Prefix Sum & Hashing: Practice problems involving subarray sums or finding pairs/complements using hash maps for O(1) lookups.
4. In-place Operations: Master rotations, segregations (like the zeroes problem above), and other operations requiring O(1) space.
5. Simulation & Index Manipulation: Finally, tackle trickier problems that require carefully following index rules or simulating processes on the array.

This order builds from simple mechanics to combined patterns, ensuring you have the foundational skills for more complex questions.

Practice Array at Deutsche Bank