Pascal-Aufgabe: Funktion Max in einem Feld mit var. Grenzen

[BaffA]

hallo,

ich mache momentan einen Anfängerkurs für Pascal und sitze an folgender aufgabe, aber ich komme einfach nicht auf die lösung. ich habe da echt ein blackout. könnte mir dazu jemand vielleicht helfen?

ich habe nur vermutungen, was richtig sein könnte, aber ich bräuchte halt eine fundierte lösung, damit ich weiss, ob ich falsch oder richtig liege.
wäre toll, wenn mir jemand dazu helfen könnte.

Gegeben sind die Konstanten- und Typdefinitionen


const
UNTEN = 0; { Array-Untergrenze }
OBEN = 10; { Array-Obergrenze }

type
tIndex = UNTEN..OBEN;
tFeld = array[tIndex] of integer;

Welche der folgenden Funktionen bestimmen das Maximum in einem Feld mit den variablen Grenzen inUnten und inOben korrekt?
Sie können davon ausgehen, dass beim (ersten) Aufruf der Funktionen stets
UNTEN <= InUnten <= InOben <= OBEN gilt.
(Bemerkung: Bei A-D handelt es sich um keine sinnvolle Anwendung der Rekursion.)

--> A:

Code: Alles auswählen

function FeldMaxA (
          var inFeld : tFeld;
              inUnten,
              inOben : tIndex) : integer;
{ bestimmt rekursiv das Maximum in einem Feld
    mit den Grenzen inUnten und inOben }

  var
  Mitte : tIndex;
  MaxL,
  MaxR : integer;

begin
  if inUnten = inOben then
    FeldMaxA := inFeld[inUnten]
  else
  begin
    Mitte := (inUnten + inOben) div 2;
    MaxL := FeldMaxA (inFeld,inUnten,Mitte);
    MaxR := FeldMaxA (inFeld,Mitte+1,inOben);
    if MaxL > MaxR then
      FeldMaxA := MaxL
    else
      FeldMaxA := MaxR
  end
end; { FeldMaxA }

--> B:

Code: Alles auswählen

function FeldMaxB (
          var inFeld : tFeld;
              inUnten,
              inOben : tIndex) : integer;
{ bestimmt rekursiv das Maximum in einem
    Feld mit den Grenzen inUnten und inOben }

  var
  Mitte : tIndex;
  MaxL,
  MaxR : integer;

begin
  if inUnten = inOben then
    FeldMaxB := inFeld[inUnten]
  else
  begin
    Mitte := (inUnten + inOben) div 2;
    MaxL := FeldMaxB (inFeld,inUnten,Mitte);
    MaxR := FeldMaxB (inFeld,Mitte,inOben);
    if MaxL > MaxR then
      FeldMaxB := MaxL
    else
      FeldMaxB := MaxR
  end
end; { FeldMaxB }

--> C:

Code: Alles auswählen

function FeldMaxC (
          var inFeld : tFeld;
              inUnten,
              inOben : tIndex) : integer;
{ bestimmt rekursiv das Maximum in einem Feld  
    mit den Grenzen inUnten und inOben }

  var
  Mitte : tIndex;
  MaxL,
  MaxR : integer;

begin
  if inUnten > inOben then
    FeldMaxC := inFeld[inUnten]
  else
  begin
    Mitte := (inUnten + inOben) div 2;
    MaxL := FeldMaxC (inFeld,inUnten,Mitte);
    MaxR := FeldMaxC (inFeld,Mitte+1,inOben);
    if MaxL > MaxR then
      FeldMaxC := MaxL
    else
      FeldMaxC := MaxR
  end
end; { FeldMaxC }

--> D:

Code: Alles auswählen

function FeldMaxD (
          var inFeld : tFeld;
              inUnten,
              inOben : tIndex) : integer;
{ bestimmt rekursiv das Maximum in einem Feld
    mit den Grenzen inUnten und inOben }

    var
    Mitte : tIndex;
    MaxL,
    MaxR : integer;

begin
  if inUnten > inOben then
    FeldMaxD := inFeld[inUnten]
  else
  begin
    Mitte := (inUnten + inOben) div 2;
    MaxL := FeldMaxD (inFeld,inUnten,Mitte);
    MaxR := FeldMaxD (inFeld,Mitte,inOben);
    if MaxL > MaxR then
      FeldMaxD := MaxL
    else
      FeldMaxD := MaxR
  end
end; { FeldMaxD }

--> E:

Code: Alles auswählen

function FeldMaxE (
          var inFeld : tFeld;
              inUnten,
              inOben : tIndex) : integer;
{ bestimmt iterativ das Maximum in einem Feld
    mit den Grenzen inUnten und inOben }

  var
  i : tIndex;
  HilfMax : integer; { Hilfsvariable }

begin
  HilfMax := 0;
  for i := inUnten to inOben do
    if inFeld[i] > HilfMax then
      HilfMax := inFeld[i];
  FeldMaxE := HilfMax
end; { FeldMaxE }

[Xin]

Öhmm... ich finde den Unterschied zwischen A und C, bzw. B und D wohl nicht!?
Es wäre super, wenn Du die Unterschiede markieren könntest, schließlich sollte nicht jeder, der Dir helfen will, erst Fehlerbilder auflösen müssen ^^

Soweit ich das sehe, sollten alle die korrekte Lösung liefern.
Rekursion ist hier aber wirklich Blödsinn. Die Lösungen mit MaxR := ...Mitte, ... - also ohne +1, prüfen das mittlere Element zweimal, also für MaxL und MaxR - das ist überflüssig.

Ich würde E bevorzugen, wobei ich HilfMax mit der kleinsten möglichen Integerzahl initialisieren würde, weil die größte Zahl von { -5, -3, - 1 } ist nicht 0 ^^

Ansonsten willkommen im Forum.

[BaffA]

danke für deine hilfe

hier die musterlösung:

Nur die Alternative A ist richtig.

zu B) Die Funktion FeldMaxB läuft in eine Endlosschleife, wenn inUnten und inObensich um 1 unterscheiden. In diesem Fall wird durch die Zuweisung
Mitte := (inUnten + inOben) div2
der Wert von inUnten der Variablen Mittezugewiesen, da bei der Ganzzahldivision der Divisionsrest nicht berücksichtigt wird. In der Zuweisung
MaxR := FeldMaxB (inFeld, Mitte, inOben)
wird die Funktion FeldMaxB also mit unveränderten Werten für inUnten und inObenaufgerufen.

zu C) Die Funktion FeldMaxC gerät in eine Endlosschleife, wenn inUnten und inObenidentisch sind. In diesem Fall greift die Abbruchbedingung nicht, denn durch die Zuweisung
Mitte := (inUnten + inOben) div2
wird Mitte der Wert von inOben (= inUnten) zugewiesen. In der folgenden Zuweisung
MaxL := FeldMaxC (inFeld, inUnten, Mitte)
wird die Funktion FeldMaxC also mit unveränderten aktuellen Parametern aufgerufen.

zu D) analog zu B) und C)

zu E) DieFunktion FeldMaxE arbeitet nur dann korrekt, wenn das Maximum in dem Feld nichtnegativ ist. Wenn die Initialisierung der lokalen Variablen HilfMax mittels
HilfMax := inFeld[inUnten]
erfolgt wäre, würde die Funktion richtig arbeiten.