Einführung in die imperative Programmierung

WS 2017/18

Gauss mit for-Schleife

program gauss;

uses crt;
   var i ,n ,summe: integer;

BEGIN
   readln(n);
   summe:=0;
   for i:= 1 to n do
   begin
   summe := summe+i;
   end;

 writeln('Summe: ', summe); 
   
   summe:= n * (n+1) div 2;
   
   writeln('Summe: ', summe);
   
   END.

Gauss mit while-Schleife

program gauss;

uses crt;
   var i ,n ,summe: integer;

BEGIN
   readln(n);
   summe:=0;
   
   i:=0;
   while i<n do
   begin
   i:=i+1;
   summe:=summe + i;
   end;
   
   writeln('Summe: ',summe);
   
   END.

Gauss mit repeat-Schleife

program gauss;

type tIndex = 1..MAXINT;

var i  ,summe: integer;
   n: tIndex;

BEGIN
   readln(n);
   summe:=0;
   
   i:=1;
   if n>=1 then
   repeat
   summe:=summe+i;
   i:=i+1;
   until i>n;
   
   writeln('Summe: ',summe);
   
   END.

Datei lesen

program datei;

 uses crt;
   var 
   Textdatei : Text;
   zeile: string;

BEGIN
   assign(Textdatei, 'daten.txt'); 
   reset(Textdatei);
   repeat
   readln(Textdatei, zeile);
   writeln(zeile);
   until eof(Textdatei);
   
END.

Aufgabe 1

program aufg1;

var  zahl, maximum : integer;

BEGIN
   writeln('Bitte Werte eingaben, für Beenden eine 0');
   
   readln(zahl);
   maximum:= zahl;
   while zahl<>0 do
   begin 
   if zahl>maximum then
   maximum:=zahl; 
   readln(zahl); 
   end;
   
   if maximum<>0 then
   writeln('Maximum: ',maximum)
   else
   writeln('Leere Eingabefolge!')
   
 END.

Aufgabe 2

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]);

 { Verschmelzungsprozess beginnen }
   i:=1; 
   j:=1;
   k:=1;
   for k:=1 to ERGEBNISFELDLAENGE do
   begin
   if i>FELDLAENGE1 then
   begin
   ErgebnisFeld[k] := Feld2[j];
   j:=j+1
   end
   else 
   if j>FELDLAENGE2 then
   begin
   ErgebnisFeld[k] := Feld1[i];
   i:=i+1
   end
   else
   begin
   if Feld1[i] < Feld2[j] then
   begin
   ErgebnisFeld[k] := Feld1[i];
   i:=i+1
   end 
   else
   begin
   ErgebnisFeld[k] := Feld2[j];
   j:=j+1
   end
   end;
   
   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 ({Eingabematrix} var inMatrix : tMatrix;
   inZeilenNr : integer) : boolean;
   { ergibt true, falls die Summe aller Elemente mit dem
   uebergebenen Zeilenindex kleiner ist als jede
   Spaltensumme }
   
   var ZeilenSumme, Spaltensumme,i,j:integer; 
   spaltegroesserzeile: boolean;
   
   begin 
   {Zeilensumme berechnen}
   ZeilenSumme:=0;
   for i:=1 to SPALTENMAX do
   ZeilenSumme:= ZeilenSumme + inMatrix[inZeilenNr, i];
   
   j:=1;
   spaltegroesserzeile:= true;
   repeat
   {Spaltensumme berechnen}
   Spaltensumme:=0;
   for i:= 1 to ZEILENMAX do
   Spaltensumme:= Spaltensumme + inMatrix[i, j];
   j:=j+1; 
   
   if  Spaltensumme <= ZeilenSumme then
   spaltegroesserzeile:= false;
   
   until (j>SPALTENMAX) or ( not spaltegroesserzeile) ;
   
   ZeilenSummeKleiner := spaltegroesserzeile;

 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 }