______________________________________________________________
Aufgabe 3.1
___________
Quelltext:

MODULE simpleggt EXPORTS Main;
IMPORT IO;

VAR a,b : INTEGER;

(*********************************************************************)
(* Programm simpleggt liest 2 Zahlen ein und gibt den groessten      *)
(* gemeinsamen Teiler aus.                                           *)
(*********************************************************************)

BEGIN

  IO.Put("Zur Bestimmung des groessten gemeinsamen Teilers\n");
  IO.Put("bitte eine natuerliche Zahl eingeben: ");
  a:= IO.GetInt();
  IO.Put("Bitte geben sie nun die zweite Zahl ein: ");
  b:= IO.GetInt();

  a:= ABS(a);  (* Vorzeichen sind fuer Berechnung unwichtig: eliminieren *)
  b:= ABS(b);

  (* Loesungsalgorithmus nach Euklid *)
  WHILE a#b DO
    IF a>b THEN DEC(a,b) ELSE DEC(b,a) END;
  END;

  IO.Put("Der Teiler lautet: ");
  IO.PutInt(a); (* da a=b ist egal, ob a oder b ausgegeben werden. *)
  IO.Put("\n");

END simpleggt.

Testlauf:

Zur Bestimmung des groessten gemeinsamen Teilers
bitte eine natuerliche Zahl eingeben: 20
Bitte geben sie nun die zweite Zahl ein: 18
Der Teiler lautet: 2

Zur Bestimmung des groessten gemeinsamen Teilers
bitte eine natuerliche Zahl eingeben: 10
Bitte geben sie nun die zweite Zahl ein: 20
Der Teiler lautet: 10

Zur Bestimmung des groessten gemeinsamen Teilers
bitte eine natuerliche Zahl eingeben: 30
Bitte geben sie nun die zweite Zahl ein: 1
Der Teiler lautet: 1

Testlaufende.

Aufgabe 3.2
___________
Quelltext:

MODULE ggt EXPORTS Main;
IMPORT IO;

VAR a,b : INTEGER;

(*-------------------------------------------------------------------*)
(* Prozedur ggT, liest Argumente: a =x, b =y als Werte,              *)
(* gibt zurueck: groessten gemeinsamen Teiler von x und y            *)
(*-------------------------------------------------------------------*)

PROCEDURE ggT (VALUE x,y : INTEGER) :CARDINAL =

BEGIN

  x:= ABS(x); (* Vorzeichen sind fuer Berechnung unwichtig: eliminieren *)
  y:= ABS(y);

  (* Loesungsalgorithmus nach Euklid *)
  WHILE x#y DO
    IF x>y THEN DEC(x,y) ELSE DEC(y,x) END;
  END;

  RETURN x

END ggT;

(*********************************************************************)
(* Programm ggt liest 2 Zahlen ein und gibt den groessten            *)
(* gemeinsamen Teiler aus.                                           *)
(*  Aufrufe: 'ggt' -> ggT                                            *) 
(*********************************************************************)

BEGIN

  IO.Put("Zur Bestimmung des groessten gemeinsamen Teilers\n");
  IO.Put("bitte eine natuerliche Zahl eingeben: ");
  a:= IO.GetInt();
  IO.Put("Bitte geben sie nun die zweite Zahl ein: ");
  b:= IO.GetInt();

  IO.Put("Der Teiler lautet: ");
  IO.PutInt(ggT(a,b));
  IO.Put("\n");

END ggt.

Testlauf:

Zur Bestimmung des groessten gemeinsamen Teilers
bitte eine natuerliche Zahl eingeben: 100
Bitte geben sie nun die zweite Zahl ein: 75
Der Teiler lautet: 25

Zur Bestimmung des groessten gemeinsamen Teilers
bitte eine natuerliche Zahl eingeben: 30
Bitte geben sie nun die zweite Zahl ein: 3
Der Teiler lautet: 3

Zur Bestimmung des groessten gemeinsamen Teilers
bitte eine natuerliche Zahl eingeben: 100
Bitte geben sie nun die zweite Zahl ein: 200
Der Teiler lautet: 100

Testlaufende.

Aufgabe 3.3
___________
Quelltext:

MODULE bruch EXPORTS Main;
IMPORT IO;

VAR zaehler, nenner : INTEGER;            (* Komponenten des Bruches *)
VAR teiler : CARDINAL;

(*-------------------------------------------------------------------*)
(* Prozedur ggT, liest Argumente: zaehler =x, nenner =y als Werte,   *)
(* gibt zurueck: groessten gemeinsamen Teiler von x und y            *)
(*-------------------------------------------------------------------*)

PROCEDURE ggT (VALUE x,y : INTEGER) :CARDINAL =

BEGIN
  y:=ABS(y); (* Vorzeichen sind fuer Berechnung unwichtig: eliminieren *)
  x:=ABS(x);

  (* Loesungsalgorithmus nach Euklid *)
  WHILE x#y DO
    IF x>y THEN DEC(x,y) ELSE DEC(y,x) END;
  END;

  RETURN x
END ggT;

(*-------------------------------------------------------------------*)
(* Prozedur ReduceFraction, nimmt Argumente: zaehler =x, nenner =y   *)
(* als Variablen, berechnet den gekuerzten Bruch durch Division mit  *)
(* dem groessten gemeinsamen Teiler                                  *)
(*  Aufrufe: ReduceFraction -> ggT                                   *) 
(*-------------------------------------------------------------------*)

PROCEDURE ReduceFraction (VAR x,y : INTEGER) =

BEGIN

  teiler:= ggT(x,y);
  x:= x DIV teiler;
  y:= y DIV teiler;
  IF y<0 THEN x:= -x END; (* ist Nenner negativ, aendert sich das Vorzeichen *)

END ReduceFraction;

(*-------------------------------------------------------------------*)
(* Prozedur PutFraction, nimmt Argumente: zaehler =x, nenner =y      *)
(* als Werte, keine Rueckgabewerte. Gibt gekuerzten Bruch aus.       *)
(*  Aufrufe: PutFraction -> ReduceFraction -> ggT                    *) 
(*-------------------------------------------------------------------*)

PROCEDURE PutFraction(VALUE x,y : INTEGER) =

BEGIN

  ReduceFraction(x,y);

  IO.PutInt(x);
  IF ABS(y)>1 THEN
    IO.Put("/");
    IO.PutInt(ABS(y));
  END;

  IO.Put("\n");

END PutFraction;

(*********************************************************************)
(* Programm bruch liest 2 Zahlen ein und gibt diese als gekuerzten   *)
(* Bruch aus.                                                        *)
(*  Aufrufe: 'bruch' -> PutFraction -> ReduceFraction -> ggT         *) 
(*********************************************************************)

BEGIN

IO.Put("Bitte geben sie den Zaehler ein: ");
zaehler:= IO.GetInt();
IO.Put("Bitte geben sie nun den Nenner ein: ");
nenner:= IO.GetInt();

IO.Put("Der gekuerzte Bruch lautet: ");
PutFraction(zaehler,nenner);

END bruch.

Testlauf:

Bitte geben sie den Zaehler ein: 25
Bitte geben sie nun den Nenner ein: 20
Der gekuerzte Bruch lautet: 5/4

Bitte geben sie den Zaehler ein: 25
Bitte geben sie nun den Nenner ein: -5
Der gekuerzte Bruch lautet: -5

Bitte geben sie den Zaehler ein: -20
Bitte geben sie nun den Nenner ein: -7
Der gekuerzte Bruch lautet: 20/7

Testlaufende.