Einführung in die imperative Programmierung

WS 2014/15

Aufgabe 2 (mit einer For-Schleife)

program merge (input, output);
  { liest ohne Eingabeueberpruefung zwei sortierte Felder mit
  integer-Zahlen ein; beide Felder werden in Feld sortiert
  zusammengefuegt; das Ergebnis wird ausgegeben; ist die Eingabe    
  unsortiert, so ist das Ergebnisfeld nicht sortiert }

  const
  GRENZE1 = 5;
  GRENZE2 = 8;
  GRENZE = 13; { GRENZE1 + GRENZE2 }
  GRENZE1PLUS1 = 6;
  GRENZE2PLUS1 = 9;
  GRENZEPLUS1 = 14;

  type
  tIndex1 = 1..GRENZE1;
  tIndex2 = 1..GRENZE2;
  tIndex = 1..GRENZE;
  tIndex1Plus1 = 1..GRENZE1PLUS1;
  tIndex2Plus1 = 1..GRENZE2PLUS1;
  tIndexPlus1 = 1..GRENZEPLUS1;
  tFeld1 = array [tIndex1] of integer;
  tFeld2 = array [tIndex2] of integer;
  tFeld = array [tIndex] of integer;
  var
  Feld1 : tFeld1;
  Feld2 : tFeld2;
  Feld : tFeld;
  i : tIndex1Plus1;
  j : tIndex2Plus1;
  k : tIndexPlus1;
begin
  { sortierte Felder einlesen }
  writeln ('Bitte', GRENZE1:2, ' Werte des ersten Feldes ',
  'sortiert eingeben!');
  for i := 1 to GRENZE1 do
    readln (Feld1[i]);
  writeln ('Bitte', GRENZE2:2, ' Werte des zweiten Feldes ',
  'sortiert eingeben!');
  for j := 1 to GRENZE2 do
    readln (Feld2[j]);

  i:=1;
  j:=1;
  for k:=1 to GRENZE do
    {tue solange in beiden Feldern Zahlen}
    if ((i<=GRENZE1) and (j<=GRENZE2)) then
    begin
      if Feld1[i]<=Feld2[j] then
      begin
        Feld[k]:= Feld1[i];
        i:=i+1;
      end
      else
      begin
        Feld[k]:= Feld2[j];
        j:=j+1;
      end;
    end
    else
      if (i<=GRENZE1) then
      begin 
        Feld[k]:=Feld1[i];
        i:=i+1;
      end
      else
      begin
        Feld[k]:=Feld2[j];
        j:=j+1;
      end; 

  writeln ('Das Ergebnisfeld ist:');
    for k := 1 to GRENZE do
      write (Feld[k]:8);
    writeln
end. { merge }

Aufgabe 2 Alternative (mit einer For-Schleife)

program merge2 (input, output);
  { liest ohne Eingabeueberpruefung zwei sortierte Felder mit
  integer-Zahlen ein; beide Felder werden in Feld sortiert
  zusammengefuegt; das Ergebnis wird ausgegeben; ist die Eingabe
  unsortiert, so ist das Ergebnisfeld nicht sortiert }
  
  const
  GRENZE1 = 5;
  GRENZE2 = 8;
  GRENZE = 13; { GRENZE1 + GRENZE2 }
  GRENZE1PLUS1 = 6;
  GRENZE2PLUS1 = 9;
  GRENZEPLUS1 = 14;

  type
  tIndex1 = 1..GRENZE1;
  tIndex2 = 1..GRENZE2;
  tIndex = 1..GRENZE;
  tIndex1Plus1 = 1..GRENZE1PLUS1;
  tIndex2Plus1 = 1..GRENZE2PLUS1;
  tIndexPlus1 = 1..GRENZEPLUS1;
  tFeld1 = array [tIndex1] of integer;
  tFeld2 = array [tIndex2] of integer;
  tFeld = array [tIndex] of integer;
  var
  Feld1 : tFeld1;
  Feld2 : tFeld2;
  Feld : tFeld;
  i : tIndex1Plus1;
  j : tIndex2Plus1;
  k : tIndexPlus1;

begin
  { sortierte Felder einlesen }
  writeln ('Bitte', GRENZE1:2, ' Werte des ersten Feldes ',
  'sortiert eingeben!');
  for i := 1 to GRENZE1 do
    readln (Feld1[i]);
  writeln ('Bitte', GRENZE2:2, ' Werte des zweiten Feldes ',
  'sortiert eingeben!');
  for j := 1 to GRENZE2 do
    readln (Feld2[j]);

  i:=1;
  j:=1;

  for k:=1 to GRENZE do
  {tue solange in beiden Feldern Zahlen}
  begin
   if i>GRENZE1 then
   begin
     Feld[k]:=Feld2[j];
     j:=j+1;
   end
   else 
     if j>GRENZE2 then
     begin 
       Feld[k]:=Feld1[i];
       i:=i+1;
     end 
     else 
       if Feld1[i]<=Feld2[j] then
       begin
         Feld[k]:= Feld1[i];
         i:=i+1;
       end
       else
       begin
         Feld[k]:= Feld2[j];
         j:=j+1;
       end;
  end;

  writeln ('Das Ergebnisfeld ist:');
  for k := 1 to GRENZE do
    write (Feld[k]:8);
  writeln
end. { merge }

Aufgabe 2 Alternative (mit 3 While-Schleifen)

program merge2 (input, output);
   { liest ohne Eingabeueberpruefung zwei sortierte Felder mit
   integer-Zahlen ein; beide Felder werden in Feld sortiert
   zusammengefuegt; das Ergebnis wird ausgegeben; ist die Eingabe
   unsortiert, so ist das Ergebnisfeld nicht sortiert }
   const
   GRENZE1 = 5;
   GRENZE2 = 8;
   GRENZE = 13; { GRENZE1 + GRENZE2 }
   GRENZE1PLUS1 = 6;
   GRENZE2PLUS1 = 9;
   GRENZEPLUS1 = 14;
   type
   tIndex1 = 1..GRENZE1;
   tIndex2 = 1..GRENZE2;
   tIndex = 1..GRENZE;
   tIndex1Plus1 = 1..GRENZE1PLUS1;
   tIndex2Plus1 = 1..GRENZE2PLUS1;
   tIndexPlus1 = 1..GRENZEPLUS1;
   tFeld1 = array [tIndex1] of integer;
   tFeld2 = array [tIndex2] of integer;
   tFeld = array [tIndex] of integer;
   var
   Feld1 : tFeld1;
   Feld2 : tFeld2;
   Feld : tFeld;
   i : tIndex1Plus1;
   j : tIndex2Plus1;
   k : tIndexPlus1;

begin
   { sortierte Felder einlesen }
   writeln ('Bitte', GRENZE1:2, ' Werte des ersten Feldes ',
   'sortiert eingeben!');
   for i := 1 to GRENZE1 do
   readln (Feld1[i]);
   writeln ('Bitte', GRENZE2:2, ' Werte des zweiten Feldes ',
   'sortiert eingeben!');
   for j := 1 to GRENZE2 do
 readln (Feld2[j]);

i:=1;
   j:=1;
   k:=1;

while (i<=GRENZE1) and (j<=GRENZE2) do
   {beide Feldwerte werden verglichen}
   begin
   if Feld1[i]<=Feld2[j] then
   begin
   Feld[k]:= Feld1[i];
   i:=i+1; 
   end
   else
   begin
   Feld[k]:= Feld2[j];
   j:=j+1;
   end;
   k:=k+1;
   end; 

while (i<=GRENZE1) do
   {Feld1 enthält noch Werte}
   begin
   Feld[k]:=Feld1[i];
   i:=i+1;
   k:=k+1;
   end;

while (j<=GRENZE2) do
   {Feld2 enthält noch Werte}
   begin
   Feld[k]:=Feld2[j];
   j:=j+1;
   k:=k+1;
   end;

writeln ('Das Ergebnisfeld ist:');
   for k := 1 to GRENZE do
   write (Feld[k]:8);
   writeln
   end. { merge }

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
  tZeile = 1..ZEILENMAX;
  tSpalte = 1..SPALTENMAX;
  tMatrix = array [tZeile, tSpalte] of integer;

  var
  Matrix : tMatrix;
  Zeile : tZeile;
  Spalte : tSpalte;
  Eingabe : integer;

  function ZeilenSummeKleiner(Matrix: tMatrix; zeile: integer) : boolean;
    var ZeileLokal: integer;
    fertig,
    ZeilenSpaltensummeGroesserGleich: boolean;
    Spalte: tSpalte;
    ZeilenSumme, 
    SpaltenSumme: integer;

  begin
    ZeilenSumme:=0;
    for Spalte:= 1 to  SPALTENMAX do
      ZeilenSumme:=ZeilenSumme+ Matrix[zeile, Spalte];
   
    Spalte:=1; 
   
    repeat
      SpaltenSumme:=0;
      for ZeileLokal:=1 to ZEILENMAX do
        SpaltenSumme:= SpaltenSumme + Matrix[ZeileLokal, Spalte];
      if SpaltenSumme<= ZeilenSumme then
        ZeilenSpaltensummeGroesserGleich:= true
      else 
        if Spalte< SPALTENMAX then
          Spalte:= Spalte+1
        else 
          fertig:= true; 
    until  fertig or ZeilenSpaltensummeGroesserGleich;
   
   ZeilenSummeKleiner := not ZeilenSpaltensummeGroesserGleich;

end;
 

begin
   { Matrixelemente einlesen }
   for Zeile := 1 to ZEILENMAX do
   for Spalte := 1 to SPALTENMAX do
   readln (Matrix[Zeile, Spalte]);
   repeat
   write ('Welche Zeile soll überprüft werden ? (1..',
   ZEILENMAX:1, ') (anderes = Ende) ');
   readln (Eingabe);
   if (Eingabe > 0) and (Eingabe <= ZEILENMAX) then
   begin
   Zeile := Eingabe;
   if ZeilenSummeKleiner (Matrix, Eingabe) then
   writeln ('Jede Spaltensumme ist größer als die ',
   'Zeilensumme der ',Zeile:1,'. Zeile.')
   else
   writeln ('Es sind nicht alle Spaltensummen größer als ',
 

'die Zeilensumme der ',Zeile:1,'. Zeile.')
   end;
   until (Eingabe <= 0) or (Eingabe > ZEILENMAX)
   end. { MatrixSummen }

Gauß (Summe 1 - n)

program gauss;
  {Summiert alle Zahlen von 1 bis n}
   
  uses crt;
  var 
  n,
  i,
  summe,
  fak : integer;

BEGIN
  readln(n);
   
  summe:=0;
  for i:=1 to n do
  begin
    summe := summe+i;
  end; 
   
  writeln('Summe 1 bis n: ', summe); 
   
  fak:=1;
  for i:= 1 to n do
    fak:= fak*i;
   
  writeln('Produkt 1 bis n: ', fak); 
   
END.

Matrix einlesen und auslesen

program untitled;

  const
  ZEILEN = 3;
  SPALTEN = 3;
   
  type 
  tMatrix = array[ 1..ZEILEN , 1..SPALTEN] of integer;
   
  var 
  i,
  j : integer;
  Matrix : tMatrix; 

BEGIN 
  for i:= 1 to ZEILEN do
    for j:=1 to SPALTEN do
      readln(Matrix[i,j]);
   
  for i:= 1 to ZEILEN do
  begin
    for j:=1 to SPALTEN do
      write(Matrix[i,j],' '); 
    writeln();
  end; 
   
END.

Palindrom

program palindrom;

  uses crt;
  var 
  wort : string;
  gedreht: string;
   
  function wortdrehen(original: string) : string;
  {dreht das Wort original um}
    var 
    umgedreht: string;
    laenge: integer;
    i: integer;
    begin
      laenge:=length(original);
   
      umgedreht:='';
      for i:=laenge downto 1 do
        umgedreht:= umgedreht + original[i];
   
      original:= umgedreht; 
      wortdrehen:= umgedreht; 
   end;

BEGIN
  readln(wort);
   
  gedreht:= wortdrehen(wort);
   
  if wort=gedreht then
    writeln('Palindrom')
  else 
    writeln('kein Palindrom') ;
   
  writeln(wort); 
   
END.

Person (Record)

program person;

  uses crt;

  type
  tPerson = record
              Name,
              Vorname: string; 
              Alter : integer;
            end {tPerson für Personen}; 

  var 
  Kunde : tPerson;

BEGIN
  readln(Kunde.Name);
  readln(Kunde.Vorname);
  readln(Kunde.Alter);
   
END.

3+1-Problem (Collatz-Problem, Ulam-Problem)

program collatz (input,output);

  uses crt;
   
  var 
  n,
  zaehler : integer;

BEGIN
  readln(n);
   
  zaehler:=0;
  while n<>1 do
  begin
    if (n mod 2) =0 then
    {n ist gerade}
      n := n div 2 
    else 
      {n ist ungerade}
      n := n * 3 +1;
    zaehler:= zaehler+1; 
    write(n,' '); 
  end;
   
  writeln();
  writeln('Durchläufe: ', zaehler);
   
END.