Greedy Questions at Deutsche Bank: What to Expect

Greedy algorithms are a core part of Deutsche Bank's technical assessment, representing about a quarter of their coding question pool. For a financial institution, the greedy paradigm—making the locally optimal choice at each step to reach a globally optimal solution—mirrors real-time decision-making in trading, resource allocation, and scheduling systems. Mastering these questions demonstrates you can think efficiently and implement straightforward, performant solutions under time constraints, a critical skill for their engineering and quantitative roles.

What to Expect — Types of Problems

Deutsche Bank's greedy questions typically fall into predictable categories. You will not encounter overly obscure problems; the focus is on applying fundamental greedy patterns to practical scenarios.

• Interval Problems: Scheduling meetings, rooms, or trades to maximize utilization. Expect variants of the classic "Meeting Rooms" or "Non-overlapping Intervals" problems.
• Assignment & Partitioning: Fairly distributing tasks or resources, often minimizing a cost or maximizing efficiency. Problems like "Assign Cookies" or "Minimum Number of Arrows to Burst Balloons" are archetypes.
• Coin Change / Greedy Selection: While the classic coin change problem is often solved with dynamic programming, greedy variants use canonical coin systems (e.g., standard currency) where taking the largest possible coin at each step is optimal.
• String Manipulation: Problems involving rearranging characters to satisfy conditions (e.g., reorganizing strings so no two adjacent characters are the same) often have a greedy construction approach.

The difficulty is usually medium. The challenge lies not in complex data structures but in recognizing the greedy property and implementing a clean, bug-free solution quickly.

How to Prepare — Study Tips with One Code Example

Your preparation should focus on pattern recognition, not memorization. Start by deeply understanding why the greedy choice works for each problem type. Prove it to yourself. Then, practice implementing the standard solutions until the code flow becomes automatic.

A key pattern is the "Sort and Greedy" approach. For many problems, especially interval-based ones, sorting the data first unlocks the optimal greedy traversal.

Consider the "Minimum Number of Arrows to Burst Balloons" problem (also known as finding the minimum number of points to overlap intervals). The greedy insight is to sort balloons by their ending coordinate. The first arrow is shot at the end of the first balloon. Any balloon that starts before this arrow position is burst by it. We then move to the next unburst balloon and repeat.

def findMinArrowShots(points):
    if not points:
        return 0
    # Sort by the end coordinate
    points.sort(key=lambda x: x[1])
    arrows = 1
    current_end = points[0][1]

    for start, end in points[1:]:
        # If the balloon starts after the last arrow position,
        # we need a new arrow.
        if start > current_end:
            arrows += 1
            current_end = end
    return arrows

Recommended Practice Order

1. Foundations: Start with basic greedy proofs and classic problems: "Assign Cookies", "Lemonade Change", "Maximum Subarray" (Kadane's Algorithm).
2. Intervals: Move to interval scheduling and merging. Practice "Meeting Rooms I & II", "Non-overlapping Intervals", and the balloon example above.
3. Strings & Construction: Tackle problems like "Task Scheduler" and "Reorganize String".
4. Deutsche Bank Specific: Finally, apply these patterns to questions tagged with Deutsche Bank on coding platforms. This bridges the gap between general knowledge and the specific format and difficulty you'll face.

Focus on writing correct code on the first try. During your interview, clearly articulate your reasoning: state the greedy choice, justify its optimality, and then code.

Practice Greedy at Deutsche Bank