Übungsaufgaben zu objektorientierten Algorithmen: Methoden über Objektlisten

Monatsbericht erstelleBericht(List<Aktivitaet> aktivitaeten) {
    int ausgebucht = 0
    int ohneMeldung = 0
    int summeZusagen = 0
    int summeErschienen = 0
    Aktivitaet schwaechste = null
    float minAuslastung = 0.0
    for (a ∈ aktivitaeten) {
        if (a.getZusagen() >= a.getPlaetze()) {
            ausgebucht = ausgebucht + 1
        }
        if (a.getErschienen() == null) {
            ohneMeldung = ohneMeldung + 1
        } else {
            summeZusagen = summeZusagen + a.getZusagen()
            summeErschienen = summeErschienen + a.getErschienen()
            float auslastung = a.getErschienen() * 1.0 / a.getPlaetze()
            if (schwaechste == null || auslastung < minAuslastung) {
                schwaechste = a
                minAuslastung = auslastung
            }
        }
    }
    float quote = 0.0
    if (summeZusagen > 0) {
        quote = (summeZusagen - summeErschienen) * 100.0 / summeZusagen
    }
    return new Monatsbericht(ausgebucht, quote, schwaechste, ohneMeldung)
}

FUNCTION erstelleBericht(aktivitaeten: List<Aktivitaet>) : Monatsbericht
    ausgebucht: integer := 0
    ohneMeldung: integer := 0
    summeZusagen: integer := 0
    summeErschienen: integer := 0
    schwaechste: Aktivitaet := nil
    minAuslastung: real := 0.0
    foreach a in aktivitaeten
        if (a.getZusagen() >= a.getPlaetze()) then
            ausgebucht := ausgebucht + 1
        end if
        if (a.getErschienen() = nil) then
            ohneMeldung := ohneMeldung + 1
        else
            summeZusagen := summeZusagen + a.getZusagen()
            summeErschienen := summeErschienen + a.getErschienen()
            auslastung: real := a.getErschienen() * 1.0 / a.getPlaetze()
            if (schwaechste = nil) OR (auslastung < minAuslastung) then
                schwaechste := a
                minAuslastung := auslastung
            end if
        end if
    next a
    quote: real := 0.0
    if (summeZusagen > 0) then
        quote := (summeZusagen - summeErschienen) * 100.0 / summeZusagen
    end if
    RETURN new Monatsbericht(ausgebucht, quote, schwaechste, ohneMeldung)
END erstelleBericht

Funktion erstelleBericht(aktivitaeten: List<Aktivitaet>): Monatsbericht
    ausgebucht: integer := 0
    ohneMeldung: integer := 0
    summeZusagen: integer := 0
    summeErschienen: integer := 0
    schwaechste: Aktivitaet := null
    minAuslastung: double := 0.0
    für jedes a in aktivitaeten
        wenn a.getZusagen() >= a.getPlaetze() dann
            ausgebucht := ausgebucht + 1
        Ende wenn
        wenn a.getErschienen() = null dann
            ohneMeldung := ohneMeldung + 1
        sonst
            summeZusagen := summeZusagen + a.getZusagen()
            summeErschienen := summeErschienen + a.getErschienen()
            auslastung: double := a.getErschienen() * 1.0 / a.getPlaetze()
            wenn schwaechste = null oder auslastung < minAuslastung dann
                schwaechste := a
                minAuslastung := auslastung
            Ende wenn
        Ende wenn
    Ende für
    quote: double := 0.0
    wenn summeZusagen > 0 dann
        quote := (summeZusagen - summeErschienen) * 100.0 / summeZusagen
    Ende wenn
    Rückgabe new Monatsbericht(ausgebucht, quote, schwaechste, ohneMeldung)
Ende erstelleBericht

int importieren(String pfad) {
    List<String> zeilen = Textdatei.liesAlleZeilen(pfad)
    int neu = 0
    for (int i = 1 … zeilen.size()-1) {
        String felder[] = zeilen.get(i).split(";")
        if (length(felder) != 3) {
            protokoll.add("Zeile " + (i + 1) + ": Feldzahl")
        } else {
            String email = felder[0].trim().toLowerCase()
            String rolle = felder[2].trim()
            if (rolle == "") {
                rolle = "Teilnahme"
            }
            if (!email.contains("@")) {
                protokoll.add("Zeile " + (i + 1) + ": E-Mail ungültig")
            } else {
                Anmeldung vorhanden = suche(email)
                if (vorhanden == null) {
                    anmeldungen.add(new Anmeldung(email, felder[1].trim(), rolle))
                    neu = neu + 1
                } else {
                    vorhanden.setName(felder[1].trim())
                    vorhanden.setRolle(rolle)
                    protokoll.add("Zeile " + (i + 1) + ": aktualisiert")
                }
            }
        }
    }
    return neu
}

FUNCTION importieren(pfad: String) : integer
    zeilen: List<String> := Textdatei.liesAlleZeilen(pfad)
    neu: integer := 0
    for i := 1 to zeilen.size() - 1 do
        felder: array of String := zeilen.get(i).split(";")
        if (length(felder) <> 3) then
            protokoll.add("Zeile " & (i + 1) & ": Feldzahl")
        else
            email: String := felder[0].trim().toLowerCase()
            rolle: String := felder[2].trim()
            if (rolle = "") then
                rolle := "Teilnahme"
            end if
            if (NOT email.contains("@")) then
                protokoll.add("Zeile " & (i + 1) & ": E-Mail ungültig")
            else
                vorhanden: Anmeldung := suche(email)
                if (vorhanden = nil) then
                    anmeldungen.add(new Anmeldung(email, felder[1].trim(), rolle))
                    neu := neu + 1
                else
                    vorhanden.setName(felder[1].trim())
                    vorhanden.setRolle(rolle)
                    protokoll.add("Zeile " & (i + 1) & ": aktualisiert")
                end if
            end if
        end if
    end for
    RETURN neu
END importieren

Funktion importieren(pfad: string): integer
    zeilen: List<string> := Textdatei.liesAlleZeilen(pfad)
    neu: integer := 0
    zähle i von 1 bis zeilen.size() - 1
        felder: string[] := zeilen.get(i).split(";")
        wenn laenge(felder) <> 3 dann
            protokoll.add("Zeile " & (i + 1) & ": Feldzahl")
        sonst
            email: string := felder[0].trim().toLowerCase()
            rolle: string := felder[2].trim()
            wenn rolle = "" dann
                rolle := "Teilnahme"
            Ende wenn
            wenn nicht email.contains("@") dann
                protokoll.add("Zeile " & (i + 1) & ": E-Mail ungültig")
            sonst
                vorhanden: Anmeldung := suche(email)
                wenn vorhanden = null dann
                    anmeldungen.add(new Anmeldung(email, felder[1].trim(), rolle))
                    neu := neu + 1
                sonst
                    vorhanden.setName(felder[1].trim())
                    vorhanden.setRolle(rolle)
                    protokoll.add("Zeile " & (i + 1) & ": aktualisiert")
                Ende wenn
            Ende wenn
        Ende wenn
    Ende zähle
    Rückgabe neu
Ende importieren

List<Angebot> passendeAngebote(Gesuch g) {
    List<Angebot> ergebnis = new List<Angebot>()
    for (a ∈ angebote) {
        boolean imFenster = !a.getAbfahrt().istVor(g.getFruehestens()) && !g.getSpaetestens().istVor(a.getAbfahrt())
        boolean gleicherWeg = a.getHaltepunkt().equals(g.getHaltepunkt()) && a.getRichtung() == g.getRichtung()
        if (gleicherWeg && imFenster && a.getFreiePlaetze() > 0 && !a.getFahrer().equals(g.getErsteller())) {
            ergebnis.add(a)
        }
    }
    return ergebnis
}

FUNCTION passendeAngebote(g: Gesuch) : List<Angebot>
    ergebnis: List<Angebot> := new List<Angebot>()
    foreach a in angebote
        imFenster: boolean := NOT a.getAbfahrt().istVor(g.getFruehestens()) AND NOT g.getSpaetestens().istVor(a.getAbfahrt())
        gleicherWeg: boolean := a.getHaltepunkt().equals(g.getHaltepunkt()) AND (a.getRichtung() = g.getRichtung())
        if gleicherWeg AND imFenster AND (a.getFreiePlaetze() > 0) AND NOT a.getFahrer().equals(g.getErsteller()) then
            ergebnis.add(a)
        end if
    next a
    RETURN ergebnis
END passendeAngebote

Funktion passendeAngebote(g: Gesuch): List<Angebot>
    ergebnis: List<Angebot> := new List<Angebot>()
    für jedes a in angebote
        imFenster: boolean := nicht a.getAbfahrt().istVor(g.getFruehestens()) und nicht g.getSpaetestens().istVor(a.getAbfahrt())
        gleicherWeg: boolean := a.getHaltepunkt().equals(g.getHaltepunkt()) und a.getRichtung() = g.getRichtung()
        wenn gleicherWeg und imFenster und a.getFreiePlaetze() > 0 und nicht a.getFahrer().equals(g.getErsteller()) dann
            ergebnis.add(a)
        Ende wenn
    Ende für
    Rückgabe ergebnis
Ende passendeAngebote

List<Angebot> nachAbfahrtSortiert(Gesuch g) {
    List<Angebot> sortiert = new List<Angebot>()
    for (a ∈ passendeAngebote(g)) {
        int pos = 0
        while (pos < sortiert.size() && !a.getAbfahrt().istVor(sortiert.get(pos).getAbfahrt())) {
            pos = pos + 1
        }
        sortiert.add(pos, a)
    }
    return sortiert
}

FUNCTION nachAbfahrtSortiert(g: Gesuch) : List<Angebot>
    sortiert: List<Angebot> := new List<Angebot>()
    foreach a in passendeAngebote(g)
        pos: integer := 0
        while (pos < sortiert.size()) AND NOT a.getAbfahrt().istVor(sortiert.get(pos).getAbfahrt()) do
            pos := pos + 1
        end while
        sortiert.add(pos, a)
    next a
    RETURN sortiert
END nachAbfahrtSortiert

Funktion nachAbfahrtSortiert(g: Gesuch): List<Angebot>
    sortiert: List<Angebot> := new List<Angebot>()
    für jedes a in passendeAngebote(g)
        pos: integer := 0
        solange pos < sortiert.size() und nicht a.getAbfahrt().istVor(sortiert.get(pos).getAbfahrt())
            pos := pos + 1
        Ende solange
        sortiert.add(pos, a)
    Ende für
    Rückgabe sortiert
Ende nachAbfahrtSortiert

boolean anfragen(Angebot a, Nutzer n) {
    if (a.getFreiePlaetze() == 0 || a.getFahrer().equals(n)) {
        return false
    }
    boolean konflikt = false
    for (x ∈ angebote) {
        if (x.getRichtung() == a.getRichtung() && x.getAbfahrt().gleicherTag(a.getAbfahrt())) {
            for (b ∈ x.getBuchungen()) {
                if (b.getMitfahrer().equals(n)) {
                    konflikt = true
                }
            }
        }
    }
    if (konflikt) {
        return false
    }
    a.buchungHinzufuegen(new Buchung(n, Zeitpunkt.jetzt()))
    return true
}

FUNCTION anfragen(a: Angebot, n: Nutzer) : boolean
    if (a.getFreiePlaetze() = 0) OR a.getFahrer().equals(n) then
        RETURN false
    end if
    konflikt: boolean := false
    foreach x in angebote
        if (x.getRichtung() = a.getRichtung()) AND x.getAbfahrt().gleicherTag(a.getAbfahrt()) then
            foreach b in x.getBuchungen()
                if (b.getMitfahrer().equals(n)) then
                    konflikt := true
                end if
            next b
        end if
    next x
    if (konflikt) then
        RETURN false
    end if
    a.buchungHinzufuegen(new Buchung(n, Zeitpunkt.jetzt()))
    RETURN true
END anfragen

Funktion anfragen(a: Angebot, n: Nutzer): boolean
    wenn a.getFreiePlaetze() = 0 oder a.getFahrer().equals(n) dann
        Rückgabe false
    Ende wenn
    konflikt: boolean := false
    für jedes x in angebote
        wenn x.getRichtung() = a.getRichtung() und x.getAbfahrt().gleicherTag(a.getAbfahrt()) dann
            für jedes b in x.getBuchungen()
                wenn b.getMitfahrer().equals(n) dann
                    konflikt := true
                Ende wenn
            Ende für
        Ende wenn
    Ende für
    wenn konflikt dann
        Rückgabe false
    Ende wenn
    a.buchungHinzufuegen(new Buchung(n, Zeitpunkt.jetzt()))
    Rückgabe true
Ende anfragen

Map<String, Integer> mengeJeArtikel(List<Verkauf> verkaeufe, Datum start, Datum ende) {
    Map<String, Integer> ergebnis = new HashMap<String, Integer>()
    for (v ∈ verkaeufe) {
        if (start <= v.getDatum() && v.getDatum() <= ende) {
            String nr = v.getArtikelNr()
            if (ergebnis.containsKey(nr)) {
                ergebnis.put(nr, ergebnis.get(nr) + v.getMenge())
            } else {
                ergebnis.put(nr, v.getMenge())
            }
        }
    }
    return ergebnis
}

FUNCTION mengeJeArtikel(verkaeufe: List<Verkauf>, start: Datum, ende: Datum) : Map<String, integer>
    ergebnis: Map<String, integer> := new HashMap<String, integer>()
    foreach v in verkaeufe
        if (start <= v.getDatum()) AND (v.getDatum() <= ende) then
            nr: String := v.getArtikelNr()
            if (ergebnis.containsKey(nr)) then
                ergebnis.put(nr, ergebnis.get(nr) + v.getMenge())
            else
                ergebnis.put(nr, v.getMenge())
            end if
        end if
    next v
    RETURN ergebnis
END mengeJeArtikel

Funktion mengeJeArtikel(verkaeufe: List<Verkauf>, start: Datum, ende: Datum): Map<string, integer>
    ergebnis: Map<string, integer> := new HashMap<string, integer>()
    für jedes v in verkaeufe
        wenn start <= v.getDatum() und v.getDatum() <= ende dann
            nr: string := v.getArtikelNr()
            wenn ergebnis.containsKey(nr) dann
                ergebnis.put(nr, ergebnis.get(nr) + v.getMenge())
            sonst
                ergebnis.put(nr, v.getMenge())
            Ende wenn
        Ende wenn
    Ende für
    Rückgabe ergebnis
Ende mengeJeArtikel

    for (int i = 0 … verkaeufe.size()-1) {
        if (start <= v.getDatum() && v.getDatum() <= ende) {
                ergebnis.put(v.getArtikelNr(), ergebnis.get(v.getArtikelNr()) + v.getMenge())

    for i := 0 to verkaeufe.size() - 1 do
        if (start <= v.getDatum()) AND (v.getDatum() <= ende) then
                ergebnis.put(v.getArtikelNr(), ergebnis.get(v.getArtikelNr()) + v.getMenge())

    zähle i von 0 bis verkaeufe.size() - 1
        wenn start <= v.getDatum() und v.getDatum() <= ende dann
                ergebnis.put(v.getArtikelNr(), ergebnis.get(v.getArtikelNr()) + v.getMenge())

int staerksterWochentag(List<Verkauf> verkaeufe) {
    float umsatz[] = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
    for (v ∈ verkaeufe) {
        int index = v.getDatum().getWochentag() - 1
        umsatz[index] = umsatz[index] + v.getMenge() * v.getEinzelpreis()
    }
    int besterIndex = 0
    for (int i = 1 … 6) {
        if (umsatz[i] > umsatz[besterIndex]) {
            besterIndex = i
        }
    }
    return besterIndex + 1
}

FUNCTION staerksterWochentag(verkaeufe: List<Verkauf>) : integer
    umsatz: array [0..6] of real := [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
    foreach v in verkaeufe
        index: integer := v.getDatum().getWochentag() - 1
        umsatz[index] := umsatz[index] + v.getMenge() * v.getEinzelpreis()
    next v
    besterIndex: integer := 0
    for i := 1 to 6 do
        if (umsatz[i] > umsatz[besterIndex]) then
            besterIndex := i
        end if
    end for
    RETURN besterIndex + 1
END staerksterWochentag

Funktion staerksterWochentag(verkaeufe: List<Verkauf>): integer
    umsatz: double[7] := [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
    für jedes v in verkaeufe
        index: integer := v.getDatum().getWochentag() - 1
        umsatz[index] := umsatz[index] + v.getMenge() * v.getEinzelpreis()
    Ende für
    besterIndex: integer := 0
    zähle i von 1 bis 6
        wenn umsatz[i] > umsatz[besterIndex] dann
            besterIndex := i
        Ende wenn
    Ende zähle
    Rückgabe besterIndex + 1
Ende staerksterWochentag

Zeitpunkt beginnHaltephase(Ofenmesswert messwerte[], float mindest, int benoetigt) {
    int folge = 0
    int i = 0
    while (i < length(messwerte) && folge < benoetigt) {
        if (messwerte[i].getTemperatur() >= mindest) {
            folge = folge + 1
        } else {
            folge = 0
        }
        i = i + 1
    }
    if (folge < benoetigt) {
        return null
    }
    return messwerte[i - benoetigt].getZeit()
}

FUNCTION beginnHaltephase(messwerte: array of Ofenmesswert, mindest: real, benoetigt: integer) : Zeitpunkt
    folge: integer := 0
    i: integer := 0
    while (i < length(messwerte)) AND (folge < benoetigt) do
        if (messwerte[i].getTemperatur() >= mindest) then
            folge := folge + 1
        else
            folge := 0
        end if
        i := i + 1
    end while
    if (folge < benoetigt) then
        RETURN nil
    end if
    RETURN messwerte[i - benoetigt].getZeit()
END beginnHaltephase

Funktion beginnHaltephase(messwerte: Ofenmesswert[], mindest: double, benoetigt: integer): Zeitpunkt
    folge: integer := 0
    i: integer := 0
    solange i < laenge(messwerte) und folge < benoetigt
        wenn messwerte[i].getTemperatur() >= mindest dann
            folge := folge + 1
        sonst
            folge := 0
        Ende wenn
        i := i + 1
    Ende solange
    wenn folge < benoetigt dann
        Rückgabe null
    Ende wenn
    Rückgabe messwerte[i - benoetigt].getZeit()
Ende beginnHaltephase

List<Session> seiteHolen(List<Session> alle, int seite, int proSeite) {
    List<Session> ergebnis = new List<Session>()
    int erster = (seite - 1) * proSeite
    int grenze = erster + proSeite
    if (grenze > alle.size()) {
        grenze = alle.size()
    }
    for (int i = erster … grenze-1) {
        ergebnis.add(alle.get(i))
    }
    return ergebnis
}

FUNCTION seiteHolen(alle: List<Session>, seite: integer, proSeite: integer) : List<Session>
    ergebnis: List<Session> := new List<Session>()
    erster: integer := (seite - 1) * proSeite
    grenze: integer := erster + proSeite
    if (grenze > alle.size()) then
        grenze := alle.size()
    end if
    for i := erster to grenze - 1 do
        ergebnis.add(alle.get(i))
    end for
    RETURN ergebnis
END seiteHolen

Funktion seiteHolen(alle: List<Session>, seite: integer, proSeite: integer): List<Session>
    ergebnis: List<Session> := new List<Session>()
    erster: integer := (seite - 1) * proSeite
    grenze: integer := erster + proSeite
    wenn grenze > alle.size() dann
        grenze := alle.size()
    Ende wenn
    zähle i von erster bis grenze - 1
        ergebnis.add(alle.get(i))
    Ende zähle
    Rückgabe ergebnis
Ende seiteHolen

HttpAntwort sessionsAbrufen(int seite, int proSeite) {
    if (seite < 1 || proSeite < 1 || proSeite > 20) {
        return new HttpAntwort(400, JsonWandler.fehler("seite oder proSeite ungültig"))
    }
    List<Session> alle = service.alleSessions()
    int seitenGesamt = (alle.size() + proSeite - 1) / proSeite
    if (seite > 1 && seite > seitenGesamt) {
        return new HttpAntwort(404, JsonWandler.fehler("Seite " + seite + " gibt es nicht"))
    }
    HttpAntwort antwort = new HttpAntwort(200, JsonWandler.zuJson(seiteHolen(alle, seite, proSeite)))
    antwort.setHeader("X-Total-Count", "" + alle.size())
    return antwort
}

FUNCTION sessionsAbrufen(seite: integer, proSeite: integer) : HttpAntwort
    if (seite < 1) OR (proSeite < 1) OR (proSeite > 20) then
        RETURN new HttpAntwort(400, JsonWandler.fehler("seite oder proSeite ungültig"))
    end if
    alle: List<Session> := service.alleSessions()
    seitenGesamt: integer := (alle.size() + proSeite - 1) div proSeite
    if (seite > 1) AND (seite > seitenGesamt) then
        RETURN new HttpAntwort(404, JsonWandler.fehler("Seite " & seite & " gibt es nicht"))
    end if
    antwort: HttpAntwort := new HttpAntwort(200, JsonWandler.zuJson(seiteHolen(alle, seite, proSeite)))
    antwort.setHeader("X-Total-Count", "" & alle.size())
    RETURN antwort
END sessionsAbrufen

Funktion sessionsAbrufen(seite: integer, proSeite: integer): HttpAntwort
    wenn seite < 1 oder proSeite < 1 oder proSeite > 20 dann
        Rückgabe new HttpAntwort(400, JsonWandler.fehler("seite oder proSeite ungültig"))
    Ende wenn
    alle: List<Session> := service.alleSessions()
    seitenGesamt: integer := (alle.size() + proSeite - 1) div proSeite
    wenn seite > 1 und seite > seitenGesamt dann
        Rückgabe new HttpAntwort(404, JsonWandler.fehler("Seite " & seite & " gibt es nicht"))
    Ende wenn
    antwort: HttpAntwort := new HttpAntwort(200, JsonWandler.zuJson(seiteHolen(alle, seite, proSeite)))
    antwort.setHeader("X-Total-Count", "" & alle.size())
    Rückgabe antwort
Ende sessionsAbrufen

List<String> freieRaeume(int slot) {
    List<String> frei = new List<String>()
    for (int r = 0 … length(raumNr)-1) {
        if (belegung[r, slot] == null) {
            frei.add(raumNr[r])
        }
    }
    return frei
}

FUNCTION freieRaeume(slot: integer) : List<String>
    frei: List<String> := new List<String>()
    for r := 0 to length(raumNr) - 1 do
        if (belegung[r, slot] = nil) then
            frei.add(raumNr[r])
        end if
    end for
    RETURN frei
END freieRaeume

Funktion freieRaeume(slot: integer): List<string>
    frei: List<string> := new List<string>()
    zähle r von 0 bis laenge(raumNr) - 1
        wenn belegung[r][slot] = null dann
            frei.add(raumNr[r])
        Ende wenn
    Ende zähle
    Rückgabe frei
Ende freieRaeume