Einführung in die imperative Programmierung

WS 2015/16

Aufgabe 1

{$B+} {$R+}

program Maximum (input, output);
   {erwartet beliebig viele ganze Zahlen und berechnet das Maximum}

 var 
   i : integer;
   max : integer;
   
begin
   readln(i); 
   if i=0 then
   {falls erste Zhal 0 ist}
   writeln('leere Eingabefolge')
   else
   begin
   max:=i;
   repeat
   if i> max then
   max := i;
   readln(i);
   until i=0;
   writeln('Maximum ist ', max);
   end; 
end. 

Aufgabe 2

{$B+} {$R+}

program merge (input, output);
      { liest ohne Eingabeueberpruefung zwei sortierte Felder mit 
      integer-Zahlen ein; beide Felder werden in einem weiteren Feld
      sortiert zusammengefuegt; das Ergebnis wird ausgegeben; ist 
      die Eingabe unsortiert, so ist das Ergebnisfeld undefiniert }
      const
      FELDLAENGE1 = 5;
      FELDLAENGE2 = 8;
      ERGEBNISFELDLAENGE = 13; { FELDLAENGE1 + FELDLAENGE2 }
      
      type
      tFeld1 = array [1..FELDLAENGE1] of integer;
      tFeld2 = array [1..FELDLAENGE2] of integer;
      tErgebnisFeld = array [1..ERGEBNISFELDLAENGE] of integer;

 var
      Feld1 : tFeld1;
      Feld2 : tFeld2;
      ErgebnisFeld : tErgebnisFeld;
      i : integer;
      j : integer;
      k : integer;
      begin
      { sortierte Felder einlesen }
      writeln ('Bitte', FELDLAENGE1:2, ' Werte des ersten Feldes ',
      'sortiert eingeben!');
      for i := 1 to FELDLAENGE1 do
      readln (Feld1[i]);
      writeln ('Bitte', FELDLAENGE2:2, ' Werte des zweiten Feldes ',
      'sortiert eingeben!');
      for j := 1 to FELDLAENGE2 do
      readln (Feld2[j]);

 {Feld1 und Feld 2 werden verglichen}
      i:=1; 
      j:=1;
      k:=1;
      while (i<=FELDLAENGE1) and (j<=FELDLAENGE2) do
      begin
      if Feld1[i] <= Feld2[j] then
      begin
      ErgebnisFeld[k] := Feld1[i];
      i:=i+1;
      k:=k+1;
      end
      else
      begin
      ErgebnisFeld[k] := Feld2[j];
      j:=j+1;
      k:=k+1;
      end
      end;
      
      {Restfeld wird an das Ergebnis angehängt}
      while i<=FELDLAENGE1 do
      begin
      ErgebnisFeld[k]:= Feld1[i];
      i:=i+1;
      k:=k+1;
      end;
      
      while j<=FELDLAENGE2 do
      begin
      ErgebnisFeld[k]:= Feld2[j];
      j:=j+1;
      k:=k+1;
      end;
      
      writeln ('Das Ergebnisfeld ist:');
      for k := 1 to ERGEBNISFELDLAENGE do
      write (ErgebnisFeld[k], ' ');
      writeln
      end.
 

Aufgabe 3

   program MatrixSummen (input, output);
   { ueberprueft bei einer Matrix von integer-Zahlen, ob
   jede Spaltensumme groesser ist als die Zeilensumme einer
   angegebenen Zeile }

 const
   ZEILENMAX = 3;
   SPALTENMAX = 4;

 type
   tMatrix = array [1..ZEILENMAX, 1..SPALTENMAX] of integer;

 var
   Matrix : tMatrix;
   ZeilenNr,
   SpaltenNr,
   Eingabe : integer;

 function ZeilenSummeKleiner (var inMatrix : tMatrix;
   inZeilenNr : integer) : boolean;
   var
   ZeilenSumme: integer;
   SpaltenSumme: integer;
   i,j: integer;
   alleGroesser : boolean;
   
   begin 
   {Zeilensumme berechnen}
   ZeilenSumme := 0; 
   for j:= 1 to  SPALTENMAX do
   ZeilenSumme:= ZeilenSumme+ inMatrix[inZeilenNr, j];
   
   {Spalten durchlaufen}
   j:= 1;
   alleGroesser := true;
   repeat 
   SpaltenSumme:=0;
   for i:= 1 to ZEILENMAX do
   SpaltenSumme:= SpaltenSumme + inMatrix[i,j]; 
   if SpaltenSumme <= ZeilenSumme then
   alleGroesser := false;
   j:=j+1; 
   until (j> SPALTENMAX) or (alleGroesser = false);
   ZeilenSummeKleiner := alleGroesser; 
   
   end; { ZeilenSummeKleiner }

begin
   { Matrixelemente einlesen }
   for ZeilenNr := 1 to ZEILENMAX do
   for SpaltenNr := 1 to SPALTENMAX do
   read (Matrix[ZeilenNr, SpaltenNr]);

 repeat
   write ('Welche Zeile soll ueberprueft werden ? (1..',
   ZEILENMAX, ') (anderes = Ende) ');
   readln (Eingabe);

 if (Eingabe > 0) and (Eingabe <= ZEILENMAX) then
   begin
   ZeilenNr := Eingabe;
   { hier wird die Funktion ZeilenSummeKleiner aufgerufen }
   if ZeilenSummeKleiner (Matrix,ZeilenNr) then
   writeln ('Jede Spaltensumme ist groesser als die ',
   'Zeilensumme der ', ZeilenNr, '. Zeile.')
   else
   writeln ('Es sind nicht alle Spaltensummen groesser als die ',
   'Zeilensumme der ', ZeilenNr, '. Zeile.')
   end;
   until (Eingabe <= 0) or (Eingabe > ZEILENMAX)
   end. { MatrixSummen }
 

Funktionen

program gauss (input, output);

 var n : integer;
   
   function summe(n : integer): integer;
   var 
   i : integer;
   ergebnis : integer;
   begin
   ergebnis := 0;
   for i:=1 to n do
   ergebnis:= ergebnis+i;
   summe := ergebnis;
   end;
   
   begin

 readln(n);
   writeln('Summe ist ', summe(n));
   
   end. 
 

Records

program bruchrechnen (input, output);

 type 
   tBruch = record 
   zaehler: integer;
   nenner : integer;
   end;
   
   var
   bruch1, bruch2, bruch3 : tBruch;
   
   function produkt(br1 : tbruch; br2 : tBruch): tBruch;
   var ergebnis: tBruch;
   begin
   produkt.zaehler:= br1.zaehler * br2.zaehler;
   produkt.nenner:=  br1.nenner * br2.nenner;
   {produkt := ergebnis;}
   end;
   
   begin
   writeln('Bruch 1 eingeben');
   readln( bruch1.zaehler, bruch1.nenner);
   
   writeln('Bruch 2 eingeben');
   readln( bruch2.zaehler, bruch2.nenner);
   
   bruch3 := produkt(bruch1, bruch2);
   
   writeln('Produkt ist ', bruch3.zaehler,'/',bruch3.nenner);

end.