Observer Pattern Problem

[archer1000]

Hallo Leute,
Ich habe ein Problem beim Lösen dieses Problems.

Aufgabestellung:
Bei der Tour de France gibt es eine Bergwertung und eine Sprintwertung. Überfährt ein Fahrer eine Berg- bzw. Sprintwertungslinie, so wird sein persönlicher Berg- bzw. Sprint- Punktestand aktualisiert. Die Tabellen der beiden Wertungen sollen in einem solchen Fall ebenfalls (sofort) aktualisiert werden.

a) Um welches Design Pattern handelt es sich? Begründen Sie ihre Wahl!
b) Welche Varianten des Patterns gibt es? Erklärung!
c) Erstellen Sie ein UML Diagramm des Patterns spezialisiert auf die obere Beschreibung.
d) Implementieren Sie eine der beiden Wertungstabelle. Die Tabelle soll intern als Map < Person, Integer > repräsentiert sein.


a) Observer Pattern. Begründung: Wenn das Objekt sich aktualisiert werden die davon abhängige Objekte benachrichtigt und aktualisiert. (Ich kann hier nicht genaue Begründung hinschreiben, da ich nicht weiss was hier Observable und was Observer sind. Welche Begründung wäre hier Sinnvoll?

b) es ist ok, Push und Pull variante gibt es.
c) Da scheitere ich. Normalerweisse kann ich Observerpattern mit einem abstrakten Obekt und davon abgeleitet Kokrete Objekt verknüpft mit Observern hinmalen. Aber kann ich nicht sagen, welche welche ist. Wenn ich Tabelle als Objekt nehme gibt es davon nicht ein Stück sondern zwei Stück. Es irittiert mich.
d) Wenn ich die Klassendiagramm hinmalen könnte wäre es nicht alzuscheres Problem zu implementieren denke ich mal.

Hilfe.

 

[JohannisderKaeufer]

Ein Klassendiagramm könnte so aussehen.

Zumindest ein Teil davon.

Du kannst dann zb zwei Wertungstabellen erstellen. Einmal Bergwertung und einmal Sprintwertung.

Und für jede Wertungslinie eine Instanz, bei der du dann den entsprechenden Observer registrierst.

Wenn dann ein Fahrer eine Wertungslinie überquert, also passed(Person driver) dann ruftst du notify Observers auf und übergibst den Fahrer.

Und in Wertungstabelle#update holst du den Fahrer aus dem Objekt raus und aktualisierst die Tabelle.

 

[archer1000]

Wie sieht es dann hiermit aus? Bildqualität ist miess. Aber Im Moment habe ich nur ein Webcam.
Ich habe abstracte Tabelle gemalt und zwei Methoden : fahrerhinzufuegen(Fahrer fahrer), fahrerentfernen(Fahrer fahrer) gemacht. Davon abgeleitet zwei Tabellen mit zusätzlichen Methoden passed(Fahrer fahrer, int punkte), update(Fahrer fahrer, int Punkte).
Abstrakte Klasse Fahrer habe ich mit zwei Attributen bergpunkte, sprintpunkte verpasst, und eine methode updateBergpunkte(int Punkte), updateSprintpunkte(int Punkte) verpasst. Bin ich auf dem richtigen Weg? Was sind noch zu korregieren und zu verbessern?

 

[SlaterB]

auf unterschiedliche Klassen/ unterschiedliche Methoden nur für Berg oder Sprint solltest du unbedingt verzichten,
einzelne Klassen reichen, maximal mit boolean oder Typ-Information,
verschiedene Instanzen der Klassen dienen jeweils für Berg bzw. Sprint

 

[archer1000]

auf unterschiedliche Klassen/ unterschiedliche Methoden nur für Berg oder Sprint solltest du unbedingt verzichten,
einzelne Klassen reichen, maximal mit boolean oder Typ-Information,
verschiedene Instanzen der Klassen dienen jeweils für Berg bzw. Sprint

Danke, bisher habe ich sowas gemacht.

package Klausur8;

import java.util.HashMap;

public abstract class AbstractTabelle {
	
	Fahrer dummyFahrer;
	Integer dummyPunkte;
	
	 private HashMap<Fahrer, Integer> liste = new HashMap<Fahrer, Integer>();

	 public void addFahrer(Fahrer fahrer, Integer punkte){
		 
		 liste.put(fahrer, punkte);
	 }
	 
	 public void removeFahrer(Fahrer fahrer){
		 liste.remove(fahrer);
	 }
	 
	 public boolean update(Fahrer fahrer, Integer punkte){
		 if(liste.containsKey(fahrer)){
			 liste.remove(fahrer);
			 liste.put(fahrer, punkte);
			 return true;
		 }else{
			 return false;
		 }
	 }
	 
	 public void setDummyFahrer(Fahrer fahrer){
		 this.dummyFahrer = fahrer;
	 }
	 
}

package Klausur8;

public abstract class Fahrer {
	
	String name;
	int bergPunkte = 0;
	int sprintPunkte = 0;
	
	public void setName(String name){
		this.name = name;
		
	}
	
	public String getName(){
		return this.name;		
	}
	
	public void setBergpunkte(int n){
		this.bergPunkte = n;
		
	}
	public int getBergpunkte(){
		return bergPunkte;
	}
	public void setSprintpunkte(int n){
		this.sprintPunkte = n;
	}
	public int getSprintpunkte(){
		return sprintPunkte;
	}
	

}

Ich weiss nur nicht, wie ich die beiden Tabellen einmal Sprinter und einmal Bergtabelle realisieren soll. Ich kann natürlich wie du sagst, im Hauptprogramm zwei Objekte von Klasse AbstractTabelle erzeugen. Es sollte eigentlich, bei Fahrer erst die Punkte aktualisiert werden und diese Information rüber zu jeweiligen Tabellen gebracht und dort aktualisiert werden. Aber ich sehe dadrin keine Observer Pattern Konzept mehr. Da müssen aus eine Interface oder abstracte Klasse die anderen verscheidenen Klassen abgeleitet werden.

 

[archer1000]

Wenn ich die Aufgabestellung lese sollen die jeweiligen Tabellen zwei andere Klassen sein. Aber du sagst was anders, dass ich keine zwei Klassen brauche.

 

[SlaterB]

'Tabellen' in der Aufgabe klingt noch nicht gefährlich, zwei davon können einfach zwei Objekte sein

'Implementieren Sie eine der beiden Wertungstabelle.' kann man allerdings so verstehen dass es jeweils eine Klasse wird, stimmt,
nun ja, Aufgabeninterpretationen sind immer kein Java-Problem sondern Interpretation,
du kennst hierzu die Varianten (*), entscheiden musst du selber

(*) wobei ich explizit nicht 'Welche Varianten des Patterns gibt es? Erklärung!' meine,
das ist für mich auch noch eines von vielen Rätseln, bei denen ich stark hoffe,
dass es doch vorher ein Skript/ Lehrbuch ein Kapitel mit Überschrift 'die Varianten des Patterns X' gab..

-----

> Aber ich sehe dadrin keine Observer Pattern Konzept mehr.

das ist oft wahr, Observer kann auch wegfallen, wenn eine Komponente gleich direkt mit einer anderen kommuniziert,

die Frage ist hier, wer update(Fahrer fahrer, Integer punkte) aufruft?
wenn Wertungslinie selber, dann fraglich, wenn Wertungslinie nur einen beliebigen Observer informiert, dann ist es das Pattern,

bei eigenen Klassen wie gesagt eine Gradwanderung, evtl. unsinnig,
bei Standardkomponenten wie JButton in Swing dagegen klar:
eine API-Klasse kann nicht direkt mit Code befüllt werden, welcher Aktion XY ausführt,
dort ist zwingend die Indirektion erforderlich, die API bietet nur allgemein Ereignis/ Observer an,
der Observer enthält die Aktion

 

[archer1000]

Danke, viel geholfen, nun möchte ich nochmal stören.
Die Hauptfrage mich stört ist, wer wen informiert. Wenn ich nach Aufgabestellung machen würde, stellt Hauptprogramm neue Fahrerobjekt her, was eigene Sprint, Bergpunkte und Name beinhaltet. Und bei Fahrer kann man setBergpunkte oder setSprintpunkte einbauen, bei dieser Methode informiert Fahrer automatisch die jeweiligen Tabelle und dort aktualisiert sich die Tabelle selbst.
Problem:
1. Ich habe mein HashMap Fahrer und Integer genommen. Wie kann ich aus Fahrer Objekte selbst auf dieser Liste sich selbst (den Fahrer) adden? addFahrer will (Fahrer, Integer) haben, und von Fahrer drinn kann ich nicht Fahrer übergeben also sich selbst übergeben. Versehst du was ich meine?Bei update genaus das selber Problem.
2. Sollte nicht Oberserver pattern informationsfluss andersrum laufen, nämlich von Observablen (in dem Fall von Tabellen) zu Observern (Fahrern)? Allerdings wenn ich Tabelle erst aktualisiere und dann Fahrer informieren will, wird es auch schwierig.

 

[SlaterB]

1. in Fahrer addFahrer() aufzurufen erscheint mir unnötig, das kann der Aufrufer machen, der das Fahrer-Objekt erstellt,
das Zauberwort dafür heißt aber immer: this, this ist das eigene Objekt

2.
die Tabelle wird nicht observiert, die bekommt neue Daten, zeigt sie an (evtl. observieren GUI-Elemente, eine JTable etwa bei ihren Model) und gut,
Observable ist hier die Wertungslinie! siehe Post von JohannisderKaeufer, Observer ist auch nicht der Fahrer,
na es gibt für alles verschiedene Varianten

 

[archer1000]

Ok. Ich habe es dank euch, soweit gebracht.
Getestet funktioniert auch.

package Klausur8;

import java.util.HashMap;

public abstract class AbstractTabelle {
	
	 HashMap<Fahrer, Integer> liste = new HashMap<Fahrer, Integer>();

	 public void addFahrer(Fahrer fahrer, Integer punkte){
		 
		 liste.put(fahrer, punkte);
	 }
	 
	
	 public void removeFahrer(Fahrer fahrer){
		 liste.remove(fahrer);
	 }
	 
	 public void update(Fahrer fahrer, Integer punkte){
		 if(liste.containsKey(fahrer)){
			 liste.remove(fahrer);
			 liste.put(fahrer, punkte);
			 
		 }else{
			 liste.put(fahrer, punkte);
			 
		 }
	 }
	 
	 
	 public void passed(Fahrer fahrer, Integer punkte){
		 update(fahrer, punkte);
		 notify(fahrer, punkte);
	 }
	 public void notify(Fahrer fahrer,Integer punkte ){
		 
	 }
}

package Klausur8;



public class Bergtabelle extends AbstractTabelle{
	 
	 public void notify(Fahrer fahrer, Integer punkte){
		 fahrer.setBergpunkte(punkte);
	 }
	 
	
	 
}

package Klausur8;



public class Sprinttabelle extends AbstractTabelle{
	 public void notify(Fahrer fahrer, Integer punkte){
		 fahrer.setSprintpunkte(punkte);
	 }
	 
	 
}

package Klausur8;

public class Fahrer {
	Fahrer(String name, int bergPunkte, int sprintPunkte){
		
		this.name = name;
		this.bergPunkte = bergPunkte;
		this.sprintPunkte = sprintPunkte;
		
	}
	
	private String name;
	public int bergPunkte = 0;
	public int sprintPunkte = 0;
	
	public void setName(String name){
		this.name = name;
		
	}
	
	public String getName(){
		return this.name;		
	}
	
	public void setBergpunkte(int n){
		this.bergPunkte = n;
		
	}
	public int getBergpunkte(){
		return bergPunkte;
	}
	public void setSprintpunkte(int n){
		this.sprintPunkte = n;
	}
	public int getSprintpunkte(){
		return sprintPunkte;
	}
	

}

package Klausur8;

public class Hauptprogramm {
	
	public static void main(String[] args){
		Fahrer fahrer1 = new Fahrer("Steve", 0, 0);
		Fahrer fahrer2 = new Fahrer("Nora", 10, 10);
		
		Bergtabelle bergtabelle = new Bergtabelle();
		Sprinttabelle sprinttabelle = new Sprinttabelle();
		
		bergtabelle.passed(fahrer1, 60);
		sprinttabelle.passed(fahrer2, 90);
		
		System.out.println(fahrer1.bergPunkte);
		
		
		
		
	}

}

 

[archer1000]

Bitte sag mir wie man besser machen könnte. Und ob es von Observer Pattern abweicht, und wenn ja wiefern usw. Danke.

 

[SlaterB]

eine HashMap ist keine 'liste'!,
ein put überschreibt immer, vorher remove unnötig,

beim update in der Tabelle speicherst du nur die neuen Punkte, addierst sie nicht zu den vorherigen,

das Konzept einer Wertungslinie, welches z.B. über verschiedene Punktevergaben für die ersten 3 oder 20 verfügt und feststellt,
welcher Fahrer in welcher Reihenfolge drankommt und entsprechend Punkte vergibt, läßt du komplett weg,

damit fällt auch ein Observer auf diesen Observable weg, so wie JohannisderKaeufer es vorschlug und ich wenn überhaupt nur bestätigte,
was du zwischen Tabelle und Fahrer planst, ist mir unklar,
meiner Bewertung nach liegt hier kein Observer-Beispiel vor, das eigene Objekt zu notifyen zählt nicht wirklich

die main-Methode als Vorantreiber könnte an Wertungslinie aktiv Bescheid sagen, dass Fahrer X angekommen ist,
Wertungslinie vergibt die Punkte und informiert als das Observable ein gesetztes Observer,
dieser ist entweder eine Tabelle selber oder gibt jedenfalls die Information an Tabelle weiter,

 

[archer1000]

eine HashMap ist keine 'liste'!,
ein put überschreibt immer, vorher remove unnötig,

beim update in der Tabelle speicherst du nur die neuen Punkte, addierst sie nicht zu den vorherigen,

das Konzept einer Wertungslinie, welches z.B. über verschiedene Punktevergaben für die ersten 3 oder 20 verfügt und feststellt,
welcher Fahrer in welcher Reihenfolge drankommt und entsprechend Punkte vergibt, läßt du komplett weg,

damit fällt auch ein Observer auf diesen Observable weg, so wie JohannisderKaeufer es vorschlug und ich wenn überhaupt nur bestätigte,
was du zwischen Tabelle und Fahrer planst, ist mir unklar,
meiner Bewertung nach liegt hier kein Observer-Beispiel vor, das eigene Objekt zu notifyen zählt nicht wirklich

die main-Methode als Vorantreiber könnte an Wertungslinie aktiv Bescheid sagen, dass Fahrer X angekommen ist,
Wertungslinie vergibt die Punkte und informiert als das Observable ein gesetztes Observer,
dieser ist entweder eine Tabelle selber oder gibt jedenfalls die Information an Tabelle weiter,

Vielen Dank für dein sehr scharfes Gucken. Die Implmentierungs Fehler konnte ich schnell heben.

 public void update(Fahrer fahrer, Integer punkte){
		 if(liste.containsKey(fahrer)){
			 Integer n = liste.get(fahrer)+ punkte;
			 liste.put(fahrer, n);
			 
		 }else{
			 liste.put(fahrer, punkte);
			 
		 }
	 }

Aber was mit Wertungslinie gemeint war kann ich immer noch nicht verstehen. Ich dachte, ich hätte genau so gemacht, wie ihr gemeint habt. Könntest du eventuell ganz grobe Skizze von Diagramm zeigen? Dann komme ich vieleicht drauf.

 

[SlaterB]

zum x-ten Mal der Hinweis auf JohannisderKaeufer, ist das keine Skizze?
ganz klar steht in der Aufgabe, dass es von der Wertungslinie aus mit der Punktevergabe losgeht,

"so wird sein persönlicher Berg- bzw. Sprint- Punktestand aktualisiert.
Die Tabellen der beiden Wertungen sollen in einem solchen Fall ebenfalls (sofort) "
kann man so interpretieren, dass der Fahrer selber seine Punkte speichert, so hast du es ja auch implementiert,

wenn im Fahrer-Objekt aber die richtige Punktanzahl steht, bisher hast du dort übrigens auch ein Überschreiben, kein Addieren,
dann ist es ziemlich dämlich, in der Tabelle eine Map für die Punkte zu haben,
<Key = Fahrer-Objekt mit 70 Punkten, Vallue = 70>...

naja, ungenaue komische Aufgaben wie immer,
fraglich ist noch, warum gerade die Tabelle den Fahrer updatet, falls sie der einzige Observer ist, dann aber wohl vertretbar, wer sonst sollte es machen?

vorstellbar wäre für mich, dass Wertungslinie den Fahrer ändert,
und die Tabelle immer noch Observer ist, um auch ihren Stand anzugleichen,

falls du im Fahrer den Punktestand richtig berechnest, solltest du in jedem Fall auf die doppelte Berechnung verzichten,
Tabelle könnte den Wert bei sich wiederum überschreiben, aus Fahrer holen

tausende Varianten überall

 

[JohannisderKaeufer]

Mal ein Beispiel wie das implementiert aussehen kann

public enum WertungsTyp {
    BERG, SPRINT;
}

public class Fahrer {
    private String name;

    public Fahrer(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Fahrer fahrer = (Fahrer) o;

        if (name != null ? !name.equals(fahrer.name) : fahrer.name != null) return false;

        return true;
    }

    @Override
    public int hashCode() {
        return name != null ? name.hashCode() : 0;
    }

    @Override
    public String toString() {
        return name;
    }
}

Soweit klar?
Eine Klasse Ereignis, da steht das ein Fahrer gerade x Punkte bekommen hat.
Könnte man auch anders Lösen, indem man bei einer Wertung die besten drei Fahrer abspeichert, bzw. die Reihenfolge

public class Ereignis {
    private Fahrer fahrer;
    private int punkte;


    public Ereignis(Fahrer fahrer, int punkte) {
        this.fahrer = fahrer;
        this.punkte = punkte;
    }
//getter und setter
}

Das Observable, abgeleitet von java.util.Observable.
Es bekommt nur der erste Fahrer die Punkte

import java.util.Observable;

public class Wertung extends Observable {
    private int punkte;

    private boolean firstPassed = false;

    private WertungsTyp wertungsTyp;

    public Wertung(int punkte, WertungsTyp wertungsTyp) {
        this.punkte = punkte;
        this.wertungsTyp = wertungsTyp;
    }

    public void passes(Fahrer f) {
        setChanged();
        int p = 0;
        if (!firstPassed) {
            p = punkte;
            firstPassed = true;
        }

        notifyObservers(new Ereignis(f, p));
    }

    public WertungsTyp getWertungsTyp() {
        return wertungsTyp;
    }
}

Dann ein Observer, der Nachrichten von den Observables entgegennimmt. Implementiert java.util.Observer.

import java.util.HashMap;
import java.util.Map;
import java.util.Observable;
import java.util.Observer;

public class Klassement implements Observer {
    WertungsTyp wertungsTyp;
    Map<Fahrer, Integer> wertung = new HashMap<Fahrer, Integer>();

    public Klassement(WertungsTyp wertungsTyp) {
        this.wertungsTyp = wertungsTyp;
    }


    @Override
    public void update(Observable observable, Object o) {
        if (observable instanceof Wertung) {
            WertungsTyp wt = ((Wertung) observable).getWertungsTyp();
            if (wt == wertungsTyp) {
                if (o instanceof Ereignis) {
                    Ereignis e = (Ereignis) o;
                    Fahrer f = e.getFahrer();
                    if (wertung.containsKey(f)) {
                        wertung.put(f, wertung.get(f) + e.getPunkte());
                    } else {
                        wertung.put(f, e.getPunkte());
                    }
                }
            }
        }
    }

    public String toString() {
        StringBuffer b = new StringBuffer(wertungsTyp + "-Wertung\n");
        for (Fahrer f : wertung.keySet()) {
            b.append(String.format("%-15s : %3d Punkte%n", f.getName(), wertung.get(f)));
        }
        return b.toString();
    }
}

Und eine Klasse ConsoleObserver die ausgibt, wenn ein Fahrer eine Wertung passiert.

import java.util.Observable;
import java.util.Observer;

public class ConsoleObserver implements Observer {

    @Override
    public void update(Observable observable, Object o) {
        if (observable instanceof Wertung) {
            WertungsTyp wt = ((Wertung) observable).getWertungsTyp();
            if (o instanceof Ereignis) {
                Ereignis e = (Ereignis) o;
                System.out.printf("%-15s passes %-6s and gets %4d points %n", e.getFahrer(), wt.toString(), e.getPunkte());
            }

        }
    }
}

Und ein Programm das das ganze zusammenbaut

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Main {

    public static void main(String[] args) {
        List<Fahrer> fahrerFeld = new ArrayList<Fahrer>();
        fahrerFeld.add(new Fahrer("Lance Armstrong"));
        fahrerFeld.add(new Fahrer("Klöden"));
        fahrerFeld.add(new Fahrer("Jens Ulrich"));
        fahrerFeld.add(new Fahrer("Jens Voigt"));

        Klassement bergWertung = new Klassement(WertungsTyp.BERG);
        Klassement sprintWertung = new Klassement(WertungsTyp.SPRINT);
        ConsoleObserver consoleObserver = new ConsoleObserver();

        List<Wertung> wertungen = new ArrayList<Wertung>();
        for (int i = 0; i < 10; i++) {
            wertungen.add(new Wertung(10, WertungsTyp.BERG));
            wertungen.add(new Wertung(10, WertungsTyp.SPRINT));
        }

        for (Wertung w : wertungen) {
            w.addObserver(bergWertung);
            w.addObserver(sprintWertung);
            w.addObserver(consoleObserver);
        }
        //Ein wenig Spannung, indem gemischt wird
        Collections.shuffle(wertungen);

        for (Wertung w : wertungen) {
            Collections.shuffle(fahrerFeld);
            for (Fahrer f : fahrerFeld) {
                w.passes(f);
            }
        }

        System.out.println("\n Die Ergebnisse\n ");
        System.out.println(bergWertung);
        System.out.println(sprintWertung);
    }
}

Und dann kommt z.B heraus:

Klöden          passes BERG   and gets   10 points 
Jens Ulrich     passes BERG   and gets    0 points 
Lance Armstrong passes BERG   and gets    0 points 
Jens Voigt      passes BERG   and gets    0 points 
Jens Voigt      passes SPRINT and gets   10 points 
Jens Ulrich     passes SPRINT and gets    0 points 
Klöden          passes SPRINT and gets    0 points 
Lance Armstrong passes SPRINT and gets    0 points 
Jens Ulrich     passes BERG   and gets   10 points 
Jens Voigt      passes BERG   and gets    0 points 
Lance Armstrong passes BERG   and gets    0 points 
Klöden          passes BERG   and gets    0 points 
Jens Ulrich     passes SPRINT and gets   10 points 
Lance Armstrong passes SPRINT and gets    0 points 
Klöden          passes SPRINT and gets    0 points 
Jens Voigt      passes SPRINT and gets    0 points 
Lance Armstrong passes SPRINT and gets   10 points 
Jens Voigt      passes SPRINT and gets    0 points 
Klöden          passes SPRINT and gets    0 points 
Jens Ulrich     passes SPRINT and gets    0 points 
Jens Voigt      passes SPRINT and gets   10 points 
Jens Ulrich     passes SPRINT and gets    0 points 
Klöden          passes SPRINT and gets    0 points 
Lance Armstrong passes SPRINT and gets    0 points 
Jens Ulrich     passes BERG   and gets   10 points 
Lance Armstrong passes BERG   and gets    0 points 
Jens Voigt      passes BERG   and gets    0 points 
Klöden          passes BERG   and gets    0 points 
Klöden          passes SPRINT and gets   10 points 
Lance Armstrong passes SPRINT and gets    0 points 
Jens Ulrich     passes SPRINT and gets    0 points 
Jens Voigt      passes SPRINT and gets    0 points 
Klöden          passes BERG   and gets   10 points 
Lance Armstrong passes BERG   and gets    0 points 
Jens Ulrich     passes BERG   and gets    0 points 
Jens Voigt      passes BERG   and gets    0 points 
Jens Voigt      passes SPRINT and gets   10 points 
Klöden          passes SPRINT and gets    0 points 
Jens Ulrich     passes SPRINT and gets    0 points 
Lance Armstrong passes SPRINT and gets    0 points 
Klöden          passes SPRINT and gets   10 points 
Jens Voigt      passes SPRINT and gets    0 points 
Jens Ulrich     passes SPRINT and gets    0 points 
Lance Armstrong passes SPRINT and gets    0 points 
Klöden          passes SPRINT and gets   10 points 
Jens Voigt      passes SPRINT and gets    0 points 
Lance Armstrong passes SPRINT and gets    0 points 
Jens Ulrich     passes SPRINT and gets    0 points 
Jens Voigt      passes BERG   and gets   10 points 
Klöden          passes BERG   and gets    0 points 
Lance Armstrong passes BERG   and gets    0 points 
Jens Ulrich     passes BERG   and gets    0 points 
Lance Armstrong passes BERG   and gets   10 points 
Jens Ulrich     passes BERG   and gets    0 points 
Jens Voigt      passes BERG   and gets    0 points 
Klöden          passes BERG   and gets    0 points 
Jens Voigt      passes BERG   and gets   10 points 
Klöden          passes BERG   and gets    0 points 
Lance Armstrong passes BERG   and gets    0 points 
Jens Ulrich     passes BERG   and gets    0 points 
Jens Voigt      passes BERG   and gets   10 points 
Lance Armstrong passes BERG   and gets    0 points 
Jens Ulrich     passes BERG   and gets    0 points 
Klöden          passes BERG   and gets    0 points 
Jens Ulrich     passes SPRINT and gets   10 points 
Jens Voigt      passes SPRINT and gets    0 points 
Klöden          passes SPRINT and gets    0 points 
Lance Armstrong passes SPRINT and gets    0 points 
Jens Voigt      passes BERG   and gets   10 points 
Klöden          passes BERG   and gets    0 points 
Jens Ulrich     passes BERG   and gets    0 points 
Lance Armstrong passes BERG   and gets    0 points 
Lance Armstrong passes SPRINT and gets   10 points 
Jens Ulrich     passes SPRINT and gets    0 points 
Jens Voigt      passes SPRINT and gets    0 points 
Klöden          passes SPRINT and gets    0 points 
Klöden          passes BERG   and gets   10 points 
Jens Ulrich     passes BERG   and gets    0 points 
Jens Voigt      passes BERG   and gets    0 points 
Lance Armstrong passes BERG   and gets    0 points 

 Die Ergebnisse
 
BERG-Wertung
Klöden          :  30 Punkte
Jens Ulrich     :  20 Punkte
Lance Armstrong :  10 Punkte
Jens Voigt      :  40 Punkte

SPRINT-Wertung
Klöden          :  30 Punkte
Jens Ulrich     :  20 Punkte
Lance Armstrong :  20 Punkte
Jens Voigt      :  30 Punkte

 

[archer1000]

Ojo, Das ist Kraas. Es war gerade für mich etwas Hardcore. Vielen Dank für die ganze Mühe.