COP4533 Finalprojekt: Aktienhandelsalgorithmen mit Brute-Force, Greedy und DP

Einleitung: Warum Algorithmen für den Aktienhandel heute wichtiger sind denn je

Im Mai 2026, wo KI-gestützte Handelsbots wie ChatGPT Trader und AlphaVantage die Finanzwelt revolutionieren, ist das Verständnis fundamentaler Algorithmen zur Gewinnmaximierung unverzichtbar. Dein COP4533 Finalprojekt fordert genau das: Du musst Variationen des Stock Buy Sell to Maximize Profit-Problems lösen. Ob du nun eine Brute-Force-Lösung, einen Greedy-Ansatz oder Dynamische Programmierung einsetzt – dieser Leitfaden hilft dir, die Konzepte zu verstehen und erfolgreich umzusetzen.

Problem 1: Die einfache Einzeltransaktion

Stell dir vor, du hast eine Matrix A der Größe m × n mit Aktienkursen. Deine Aufgabe: Finde den maximalen Gewinn aus einem Kauf und Verkauf einer Aktie. Klingt einfach? Das ist die Basis für alles Weitere.

Brute-Force-Ansatz: Alle Möglichkeiten durchprobieren

Der naive Ansatz prüft für jede Aktie i jedes mögliche Kaufdatum j1 und jedes spätere Verkaufsdatum j2. Das ergibt eine Laufzeit von O(m * n²). Bei m = 1000 und n = 1000 sind das 1 Milliarde Iterationen – selbst für moderne Prozessoren eine Herausforderung. Aber für kleine Eingaben oder als Baseline ist es okay.

def brute_force_max_profit(A):
    m, n = len(A), len(A[0])
    best_profit = 0
    best_tuple = (0, 0, 0, 0)
    for i in range(m):
        for j1 in range(n):
            for j2 in range(j1+1, n):
                profit = A[i][j2] - A[i][j1]
                if profit > best_profit:
                    best_profit = profit
                    best_tuple = (i+1, j1+1, j2+1, profit)
    return best_tuple

Greedy-Algorithmus: Optimal in linearer Zeit

Ein Greedy-Ansatz für eine einzelne Transaktion ist überraschend einfach: Laufe durch die Kurse, merke dir den bisher niedrigsten Kurs und berechne den Gewinn, wenn du heute verkaufen würdest. Das liefert in O(m * n) das Optimum – denn die optimale Lösung ist der maximale Anstieg nach einem Tiefpunkt.

def greedy_max_profit(A):
    m, n = len(A), len(A[0])
    best_profit = 0
    best_tuple = (0, 0, 0, 0)
    for i in range(m):
        min_price = A[i][0]
        min_day = 0
        for j in range(1, n):
            if A[i][j] < min_price:
                min_price = A[i][j]
                min_day = j
            profit = A[i][j] - min_price
            if profit > best_profit:
                best_profit = profit
                best_tuple = (i+1, min_day+1, j+1, profit)
    return best_tuple

Dieser Algorithmus ist nicht nur schnell, sondern auch intuitiv – ähnlich wie ein Händler, der den günstigsten Einstiegspunkt sucht. Wenn du das Konzept verstanden hast, bist du bereit für komplexere Szenarien.

Problem 2: Mehrere Transaktionen mit Limit k

Jetzt wird es spannend: Du darfst bis zu k Transaktionen durchführen, aber jede besteht aus Kauf und Verkauf einer Aktie. Das ist wie ein Fantasy-Football-Manager, der Spieler zur richtigen Zeit kauft und verkauft – nur mit Aktien. Hier hilft Dynamische Programmierung.

Dynamische Programmierung: Der Schlüssel zu maximalem Gewinn

Wir definieren dp[t][j] als maximalen Gewinn mit maximal t Transaktionen bis Tag j. Die Rekursion: Entweder wir machen keine Transaktion an Tag j (dp[t][j-1]) oder wir verkaufen eine an Tag j gekaufte Aktie. Dazu brauchen wir den besten Kaufpreis max( dp[t-1][prev] - A[i][prev] ). Das führt zu einer O(m * n * k) Lösung – akzeptabel für n, k ≤ 1000.

def dp_max_profit_k_transactions(A, k):
    m, n = len(A), len(A[0])
    # Für jede Aktie einzeln DP
    all_transactions = []
    total_profit = 0
    for i in range(m):
        dp = [[0]*(n+1) for _ in range(k+1)]
        for t in range(1, k+1):
            max_diff = -A[i][0]
            for j in range(1, n):
                dp[t][j] = max(dp[t][j-1], A[i][j] + max_diff)
                max_diff = max(max_diff, dp[t-1][j] - A[i][j])
        # backtracking, um die Transaktionen zu extrahieren
        # (vereinfacht: wir summieren nur den Gewinn)
        total_profit += dp[k][n-1]
    return total_profit

Problem 3: Unbegrenzte Transaktionen

Wenn k nicht begrenzt ist, kannst du an jedem Anstieg verdienen. Das ist der einfachste Fall: Kaufe an jedem Tief, verkaufe an jedem Hoch. Ein Greedy reicht: Summiere alle positiven Differenzen zwischen aufeinanderfolgenden Tagen. Für mehrere Aktien nimmst du die beste.

def unlimited_transactions(A):
    m, n = len(A), len(A[0])
    max_profit = 0
    for i in range(m):
        profit = 0
        for j in range(1, n):
            if A[i][j] > A[i][j-1]:
                profit += A[i][j] - A[i][j-1]
        max_profit = max(max_profit, profit)
    return max_profit

Vergleich der Algorithmen

Brute-Force: Einfach, aber langsam (O(m n²)). Gut zum Verständnis.
Greedy: Optimal für Einzeltransaktion und unbegrenzte Transaktionen. Schnell (O(m n)).
Dynamische Programmierung: Notwendig für k Transaktionen. Flexibel, aber komplexer (O(m n k)).

Praktische Tipps für dein COP4533 Finalprojekt

Beginne mit dem Verständnis der Problemstellungen. Skizziere die Algorithmen auf Papier. Implementiere dann in Python oder C++. Teste mit den gegebenen Beispielen. Achte auf Randfälle: Wenn kein Gewinn möglich ist, gib (0,0,0,0) zurück. Nutze 1-basierte Indizes wie in der Aufgabenstellung.

„Algorithmen sind die Spielzüge des 21. Jahrhunderts – wer sie beherrscht, gewinnt das Spiel.“ – Inspiriert von der Welt des algorithmischen Tradings.

Fazit

Mit diesen Konzepten bist du bestens gerüstet für dein COP4533 Finalprojekt. Ob Brute-Force, Greedy oder Dynamische Programmierung – du hast die Werkzeuge, um Aktiengewinne zu maximieren. Denk daran: Übung macht den Meister. Implementiere die Algorithmen, teste sie und optimiere sie. Viel Erfolg im Mai 2026!