Java-Code

import java.awt.Color;
import java.util.ArrayList;
import java.util.List;

public class Hauptprogramm {

	public static void main(String[] args) {
		int maxSerie = 1000;
		int gewinnwahrscheinlichkeit;

		do {
			gewinnwahrscheinlichkeit = (int) (Math.random() * 100);
		} while (gewinnwahrscheinlichkeit >= 60 || gewinnwahrscheinlichkeit <= 40);

		ArrayList<ZweiwertigesGlueckspiel> glueckspiele = new ArrayList<ZweiwertigesGlueckspiel>();

		glueckspiele.add(new ZweiwertigesGlueckspiel(new statisch(), maxSerie, Color.BLACK));
		glueckspiele.add(new ZweiwertigesGlueckspiel(new martingal(), maxSerie, Color.GREEN));
		glueckspiele.add(new ZweiwertigesGlueckspiel(new reverse_martingal(), maxSerie, Color.BLUE));
		glueckspiele.add(new ZweiwertigesGlueckspiel(new Fibonacci(), maxSerie, Color.RED));

		boolean gewonnen;
		List<Integer> pleite = new ArrayList();

		for (int p = 0; p < maxSerie; p++) {
			if (((int) (Math.random() * 100) - gewinnwahrscheinlichkeit) <= 0) {
				gewonnen = true;
			} else {
				gewonnen = false;
			}

			for (int i = 0; i < glueckspiele.size(); i++) {
				try {
					if (!pleite.contains(i))
						glueckspiele.get(i).neuerZug(gewonnen);
				} catch (Exception e) {
					pleite.add(i);
				}
			}
		}

		Anzeige anzeige = new Anzeige(glueckspiele, gewinnwahrscheinlichkeit);
	}
}


import java.awt.Color;

public class ZweiwertigesGlueckspiel {
	private int runde = 0;
	private int gesetztesGeld = 1000;
	private int kontostand = gesetztesGeld;
	private int maxRunde;
	private int[] kontostandVerlauf;
	private int gewinnSerie = 0;
	private int einsatz = 1;
	private int[] einsatzVerlauf;
	boolean gewonnen;
	private Color graphFarbe;
	private IStrategie strategie;

	public ZweiwertigesGlueckspiel(IStrategie strategie, int maxSerie, Color c) {
		this.strategie = strategie;
		this.maxRunde = maxSerie;
		kontostandVerlauf = new int[maxSerie];
		kontostandVerlauf[0] = gesetztesGeld;
		this.graphFarbe = c;
		this.einsatzVerlauf = new int[maxSerie];
	}

	protected int neuerZug(boolean gewonnen) throws Exception {
		kontostand = strategie.neuerZug(this, gewonnen);
		runde++;
		kontostandVerlauf[runde] = kontostand;
		einsatzVerlauf[runde] = einsatz;
		return kontostand;
	}

	public int getRunde() {
		return runde;
	}
	public void setRunde(int runde) {
		this.runde = runde;
	}
	public int getGesetztesGeld() {
		return gesetztesGeld;
	}
	public void setGesetztesGeld(int gesetztesGeld) {
		this.gesetztesGeld = gesetztesGeld;
	}
	public int getKontostand() {
		return kontostand;
	}
	public void setKontostand(int kontostand) {
		this.kontostand = kontostand;
	}
	public int getMaxRunde() {
		return maxRunde;
	}
	public void setMaxRunde(int maxRunde) {
		this.maxRunde = maxRunde;
	}
	public int[] getVerlauf() {
		return kontostandVerlauf;
	}
	public void setVerlauf(int[] verlauf) {
		this.kontostandVerlauf = verlauf;
	}
	public int getGewinnSerie() {
		return gewinnSerie;
	}
	public void setGewinnSerie(int gewinnSerie) {
		this.gewinnSerie = gewinnSerie;
	}
	public int getEinsatz() {
		return einsatz;
	}
	public void setEinsatz(int einsatz) {
		this.einsatz = einsatz;
	}
	public IStrategie getStrategie() {
		return strategie;
	}
	public void setStrategie(IStrategie strategie) {
		this.strategie = strategie;
	}
	public Color getGraphFarbe() {
		return graphFarbe;
	}
	public void setGraphFarbe(Color graphFarbe) {
		this.graphFarbe = graphFarbe;
	}
	public int[] getEinsatzVerlauf() {
		return einsatzVerlauf;
	}
	public void setEinsatzVerlauf(int[] einsatzVerlauf) {
		this.einsatzVerlauf = einsatzVerlauf;
	}
}


public interface IStrategie {
	int neuerZug(ZweiwertigesGlueckspiel glueck, boolean gewinn) throws Exception;
}


public class statisch implements IStrategie {
	public int neuerZug(ZweiwertigesGlueckspiel glueck, boolean gewonnen) throws Exception {
		if (glueck.getKontostand() > 0 && glueck.getKontostand() < (glueck.getGesetztesGeld() * 2)) {
			if (gewonnen) {
				return (glueck.getKontostand() + glueck.getEinsatz());
			} else {
				return (glueck.getKontostand() - glueck.getEinsatz());
			}
		} else
			throw new Exception("Kein neuer Zug möglich");
	}

	public String toString() {
		return "statisch";
	}
}


public class martingal implements IStrategie {
	public int neuerZug(ZweiwertigesGlueckspiel glueck, boolean gewonnen) throws Exception {
		if (glueck.getKontostand() > 0 && glueck.getKontostand() < (glueck.getGesetztesGeld() * 2)) {
			if (gewonnen) {
				int gewinn = glueck.getKontostand() + glueck.getEinsatz();
				glueck.setEinsatz(1);
				return gewinn;
			} else {
				int verlust = glueck.getKontostand() - glueck.getEinsatz();
				if (glueck.getEinsatz() * 2 < glueck.getKontostand()) {
					glueck.setEinsatz(glueck.getEinsatz() * 2);
				} else {
					glueck.setEinsatz(glueck.getKontostand());
				}
				return verlust;
			}
		} else
			throw new Exception("Kein neuer Zug möglich");
	}

	public String toString() {
		return "martingal";
	}
}


public class reverse_martingal implements IStrategie {
	public int neuerZug(ZweiwertigesGlueckspiel glueck, boolean gewonnen) throws Exception {
		int angestrebteGewinnSerie = 5;
		if (glueck.getKontostand() > 0 && glueck.getKontostand() < (glueck.getGesetztesGeld() * 2)) {
			if (gewonnen) {
				int gewinn = glueck.getKontostand() + glueck.getEinsatz();
				glueck.setGewinnSerie(glueck.getGewinnSerie() + 1);
				if (glueck.getGewinnSerie() < angestrebteGewinnSerie) {
					if (glueck.getKontostand() < glueck.getEinsatz() * 2) {
						glueck.setEinsatz(glueck.getKontostand());
					}
					glueck.setEinsatz(glueck.getEinsatz() * 2);
				} else {
					glueck.setEinsatz(1);
				}
				return gewinn;
			} else {
				int verlust = glueck.getKontostand() - glueck.getEinsatz();
				glueck.setEinsatz(1);
				glueck.setGewinnSerie(0);
				return verlust;
			}
		} else
			throw new Exception("Kein neuer Zug möglich");
	}

	public String toString() {
		return "reverse-martingal";
	}
}


public class Fibonacci implements IStrategie {
	private int fiboEinsatz[] = new int[20];
	int position = 1;

	public Fibonacci() {
		fiboEinsatz[0] = 1;
		fiboEinsatz[1] = 1;
		for (int i = 2; i < 20; i++) {
			fiboEinsatz[i] = fiboEinsatz[i - 1] + fiboEinsatz[i - 2];
		}
	}

	public int neuerZug(ZweiwertigesGlueckspiel glueck, boolean gewonnen) throws Exception {
		if (glueck.getKontostand() > 0 && glueck.getKontostand() < (glueck.getGesetztesGeld() * 2)) {
			if (gewonnen) {
				int gewinn = glueck.getKontostand() + glueck.getEinsatz();
				if (!(position <= 1))
					position = position - 2;
				if (fiboEinsatz[position] <= glueck.getKontostand()) {
					glueck.setEinsatz(fiboEinsatz[position]);
				} else {
					glueck.setEinsatz(glueck.getKontostand());
				}
				return gewinn;
			} else {
				int verlust = glueck.getKontostand() - glueck.getEinsatz();
				position++;
				if (fiboEinsatz[position] <= glueck.getKontostand()) {
					glueck.setEinsatz(fiboEinsatz[position]);
				} else {
					glueck.setEinsatz(glueck.getKontostand());
				}
				return verlust;
			}
		} else
			throw new Exception("Kein neuer Zug möglich");
	}

	public String toString() {
		return "Fibonacci";
	}
}


import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.util.ArrayList;
import javax.swing.JFrame;
import javax.swing.JPanel;

public class Anzeige extends JFrame {
	ArrayList<ZweiwertigesGlueckspiel> data = new ArrayList<ZweiwertigesGlueckspiel>();

	public Anzeige(ArrayList<ZweiwertigesGlueckspiel> glueckspiele, int gewinnwahrscheinlichkeit) {
		this.add(new Chart());
		this.setVisible(true);
		this.setSize(1100, 700);
		this.setDefaultCloseOperation(EXIT_ON_CLOSE);
		data = glueckspiele;
		this.setTitle("Gesetztes Geld:" + data.get(0).getGesetztesGeld() + "   Gewinnwahrscheinlichkeit: "
				+ gewinnwahrscheinlichkeit);
	}

	private class Chart extends JPanel {

		public void paintComponent(Graphics g) {
			super.paintComponent(g);
			g.setColor(Color.BLACK);

			Graphics2D g2d = (Graphics2D) g;

			for (int i = 0; i <= 1000; i += 100) {
				g2d.drawLine(0, (this.getHeight() / 2) + i / 4, this.getWidth(), (this.getHeight() / 2) + i / 4);
				g2d.drawLine(0, (this.getHeight() / 2) - i / 4, this.getWidth(), (this.getHeight() / 2) - i / 4);
				g2d.drawString("+" + i, 0, (this.getHeight() / 2) - i / 4);
				g2d.drawString("" + i * -1, 0, (this.getHeight() / 2) + i / 4);
			}

			for (int i = 0; i <= 1000; i += 100) {
				g2d.drawString("" + i, 0 + i, (this.getHeight() / 2) + 250);
			}

			Font font = g.getFont().deriveFont(20.0f);
			g2d.setFont(font);
			g2d.drawString("Runden", this.getWidth() / 2, (this.getHeight() / 2) + 275);
			g2d.drawString("Gewinn", 0, (this.getHeight() / 2) - 275);

			BasicStroke stroke = new BasicStroke(2);
			g2d.setStroke(stroke);

			for (int i = 0; i < data.size(); i++) {
				g2d.setColor(data.get(i).getGraphFarbe());
				g2d.drawString("" + data.get(i).getStrategie(), 100 + i * this.getWidth() / 4,
						(this.getHeight() / 2) - 275);

				for (int p = 0; p < data.get(i).getMaxRunde() - 1; p++) {
					g2d.drawLine(p,
							(this.getHeight() / 2)
									+ (((data.get(i).getVerlauf())[p] - data.get(i).getGesetztesGeld()) / 4) * -1,
							p + 1, (this.getHeight() / 2)
									+ (((data.get(i).getVerlauf())[p + 1] - data.get(i).getGesetztesGeld()) / 4) * -1);
				}
			}

			this.setBackground(Color.WHITE);
			this.setVisible(true);
			this.setSize(super.getSize());
		}
	}
}