Suche Leute die sich in pascal auskennen

In einem PASCAL-Programm soll eine 5×5 Matrix transponiert werden. Das heisst, die Zeilen und Spalten der Matrix sind zu vertauschen, wie im folgenden Beispiel gezeigt ist:




Wir geben folgende Typdefinition und Variablendeklaration an:


  const
  GROESSE = 5;


  type
  tIndex = 1..GROESSE;
  tMatrix = array [tIndex,tIndex] of integer;


  var
  A : tMatrix;
  hilf,
  i,
  j : integer;


Das Lesen der Matrixwerte in A wird folgendermaßen durchgeführt:


{ Lesen der Matrixwerte in A: }
  for i := 1 to GROESSE do
    for j := 1 to GROESSE do
      readln (A[i,j]);




Welche der fünf folgenden Programmstücke führen das Transponieren der Matrix A korrekt aus?


 


       


	A  	


begin
  for i := 1 to GROESSE-1 do
    for j := i+1 to GROESSE do
    begin
      hilf := A[i,j];
      A[i,j] := A[j,i];
      A[j,i] := hilf
    end
end;


	B  	


begin
  for i := 0 to GROESSE-1 do
    for j := 2 to GROESSE+1 do
      if (i+j) <= GROESSE then
      begin
        hilf := A[i+1,j+i];
        A[i+1,j+i] := A[j+i,i+1];
        A[j+i,i+1] := hilf
      end
end;


	C  	


begin
  for i := 1 to GROESSE-1 do
    for j := GROESSE downto i+1 do
    begin
      hilf :=A[i,j];
      A[j,i] := A[i,j];
      A[i,j] := hilf
    end
end;


	D  	


begin
  for i := 1 to GROESSE-1 do
  begin
    j := i+1;
    while j <= GROESSE do 
    begin
      hilf := A[i,j];
      A[i,j] := A[j,i];
      A[j,i] := hilf;
      j := j+2
    end;
  end;
  for i := 1 to GROESSE-1 do
  begin
    j := i+2;
    while j <= GROESSE do 
    begin
      hilf := A[i,j];
      A[i,j] := A[j,i];
      A[j,i] := hilf;
      j := j+2
    end
  end
end;


	E  	


begin
  for i := GROESSE-1 downto 1 do
  begin
    j := i+1;
    while j <= GROESSE do 
    begin
      hilf := A[i,j];
      A[i,j] := A[j,i];
      A[j,i] := hilf;
      j := j+2
    end;
    j := i+2;
    while j <= GROESSE do 
    begin
      hilf := A[i,j];
      A[i,j] := A[j,i];
      A[j,i] := hilf;
      j := j+2
    end
  end
end;

Die Funktion max findet in einem Feld ParFeld von integer-Werten das Maximum der Feldelemente ParFeld[von], ..., ParFeld[bis].Wir geben folgende Deklaration an:


    function max (
               ParFeld: tFeld;
               von, bis: tIndex): integer;
    { bestimmt das Maximum im Teilfeld von ParFeld[von] 
      bis ParFeld[bis] }


    var
      Wert : integer;
      i : tIndex;


   begin
      Wert := ParFeld[von];
      for i := von + 1 to bis do
        if ParFeld[i] > Wert then
          Wert := ParFeld[i];
      max := Wert
    end; { max }


Für welche der folgenden Programmstücke verlassen die Werte der aktuellen Parameter bei dem Aufruf  bzw. den Aufrufen der  Funktion max nicht den durch die formalen Parameter definierten gültigen Wertebereich, egal welche integer-Werte im Feld vorkommen? Gehen Sie dabei von folgenden Konstanten-, Typ- und Variablenvereinbarungen aus:


    const
    GRENZE = 10;


    type      
    tIndex = 1..GRENZE;
    tFeld = array [tIndex] of integer;


    var
    Feld : tFeld;
    w,
    w1,
    w2 : integer;


 


       


	A  	


w := max (Feld, Feld[1], Feld[GRENZE]);


	B  	


w := max (Feld, (GRENZE-1) div 2,
            (GRENZE-1) div 2);


	C  	


if max (Feld, 1, (GRENZE-1) div 2) >
      max (Feld, (GRENZE+1) div 2, GRENZE)
then
  w := max (Feld, 1, (GRENZE-1) div 2)
else
  w := max (Feld, (GRENZE+1) div 2, GRENZE);


	D  	


w := max (Feld, 1, GRENZE);
if w <= GRENZE then
  write (max (Feld, w, w));


	E  	


w1 := max (Feld, 1, GRENZE);
w2 := max (Feld, 4, GRENZE-1);
if (0 < w2) and (w1 <= GRENZE) then
begin
  w := max (Feld, 2, GRENZE);
  w := max (Feld, 1, w)
end;