home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD1.mdf / modula2 / library / fst / modula3 / bino.mod < prev    next >
Text File  |  1993-07-28  |  6KB  |  168 lines
  1. MODULE bino;
  2. (*********************************************************************
  3.    Berechnung des Bimomialkoeffizienten
  4.              ┌   ┐
  5.              │ N │
  6.              │ K │
  7.              └   ┘  auf rekursive und iterative Weise.
  8.  *********************************************************************)
  9. FROM InOut IMPORT ReadCard,
  10.                    WriteCard,
  11.                    WriteLn,
  12.                    Read,
  13.                    WriteString,
  14.                    ReadString;
  15. FROM IO     IMPORT WrLngCard;
  16. CONST
  17.     Min = 0;  (* kleinstmoegliche Zahl *)
  18.     Max = 69; (* groesstmoegliche Zahl *)
  19.  
  20. VAR
  21.   n, k : CARDINAL;(* diese Zahlen bilden den Binomialkoeffizienten *)
  22.   ch : CHAR;      (* Variable fuer die Tastatureingabe *)
  23.  
  24. (*******************************************************************)
  25. (* PROCEDURE lesenat                                               *)
  26. (*******************************************************************)
  27. (* Liest eine Zahl ein und gibt sie an das aufrufende Prg zurueck. *)
  28. (* Die zurueckgegebene Zahl erfuellt folgende Bedingung:           *)
  29. (*     min <= zahl <= max                                          *)
  30. (*******************************************************************)
  31. PROCEDURE lesenat(min, max : CARDINAL; m : ARRAY OF CHAR) : CARDINAL;
  32. VAR
  33.   z : CARDINAL;
  34.  
  35. BEGIN
  36.   REPEAT
  37.     WriteString(m);
  38.     WriteString(' (');
  39.     WriteCard(min, 0);
  40.     WriteString('<=zahl<=');
  41.     WriteCard(max, 0);
  42.     WriteString('): ');
  43.     ReadCard(z);                 (* solange eine Zahl einlesen *)
  44.     WriteLn;                     (* bis die Zahl *)
  45.   UNTIL (z>=min) AND (z<=max);   (* die Bedingungen erfuellt. *)
  46.   RETURN z;
  47. END lesenat;
  48.  
  49.  
  50. (*******************************************************************)
  51. (* Procedure REKURSIV                                              *)
  52. (*******************************************************************)
  53. (* Berechnet den Binomialkoeffizienten rekursiv.                   *)
  54. (*******************************************************************)
  55. PROCEDURE rekursiv(n, k : CARDINAL) : LONGCARD;
  56. BEGIN
  57.   IF (k=0) OR (k=n) THEN
  58.     RETURN 1;
  59.   ELSE
  60.     RETURN rekursiv(n-1, k) + rekursiv(n-1, k-1);
  61.   END;
  62. END rekursiv;
  63.  
  64.  
  65. (*******************************************************************)
  66. (* Procedure FAK                                                   *)
  67. (*******************************************************************)
  68. (* Berechnet die Fakultaet der Zahl z.                             *)
  69. (*******************************************************************)
  70. PROCEDURE fak(z : CARDINAL) : LONGREAL;
  71. VAR
  72.   i : CARDINAL;
  73.   f : LONGREAL;
  74.  
  75. BEGIN
  76.   IF (z=0) THEN     (* 0! = 1 *)
  77.     RETURN 1.0;
  78.   ELSE
  79.     f:=1.0;
  80.     FOR i:=2 TO z DO
  81.       f:=f*LONGREAL(i);
  82.     END;
  83.   END;
  84.   RETURN f;
  85. END fak;
  86.  
  87.  
  88. (*******************************************************************)
  89. (* Procedure NICHTREKURSIV                                         *)
  90. (*******************************************************************)
  91. (* Berechnet den Binomialkoeffizienten (n k) nach folgender Formel:*)
  92. (*                  n!                                             *)
  93. (*      (n k) = ---------                                          *)
  94. (*              k! (n-k)!                                          *)
  95. (*******************************************************************)
  96. PROCEDURE nichtrekursiv(n, k : CARDINAL) : LONGCARD;
  97. VAR
  98.   z : LONGREAL;
  99.  
  100. BEGIN
  101.   z:=fak(n)/(fak(k)*fak(n-k)); (* Koeffizienten nach Formel berechnen *)
  102.   z:=z+0.5;                    (* auf 0 Stellen runden und als *)
  103.   RETURN LONGCARD(z);          (* LONGCARD-Variable zurueckgeben *)
  104. END nichtrekursiv;
  105.  
  106.  
  107. (*******************************************************************)
  108. (* Procedure INIT                                                  *)
  109. (*******************************************************************)
  110. (* setzt die Variablen n und k auf 0 und gibt eine Nachricht aus.  *)
  111. (*******************************************************************)
  112. PROCEDURE init;
  113. BEGIN
  114.   n:=0; k:=0;
  115.   WriteLn;
  116.   WriteString('                                                   ┌N┐');
  117.   WriteLn;
  118.   WriteString('Dieses Programm berechnet den Binomialkoeffizenten └K┘');
  119.   WriteString(' auf zwei'); WriteLn;
  120.   WriteString('Arten, naemlich rekursiv bzw. nicht-rekursiv.');
  121.   WriteLn;
  122.   WriteString('Bitte beachten Sie bei der Eingabe von n und k,');
  123.   WriteString(' dass gelten muss:');
  124.   WriteString(' k<=n');
  125.   WriteLn; WriteLn;
  126. END init;
  127.  
  128.  
  129. (*******************************************************************)
  130. (* Hauptprogramm                                                   *)
  131. (*******************************************************************)
  132. BEGIN
  133.   init;
  134.   REPEAT
  135.     n:=lesenat(Min, Max, 'Bitte n eingeben');
  136.     k:=lesenat(Min, Max, 'Bitte k eingeben');
  137.     WriteLn;
  138.   UNTIL (k<=n);
  139.   WriteString('[R]ekursiv, [N]icht rekursiv oder [B]eides: ');
  140.   REPEAT
  141.     Read(ch);                      (* Was soll berechnet werden *)
  142.   UNTIL (ch='r') OR (ch='R') OR    (* r = nur rekursiv *)
  143.         (ch='n') OR (ch='N') OR    (* n = nicht rekursiv *)
  144.         (ch='b') OR (ch='B');      (* b = beides *)
  145.   WriteString(ch);
  146.   WriteLn; WriteLn;
  147.     IF (ch='r') OR (ch='R') THEN              (* rekursiv *)
  148.     WriteString('Rekursive Loesung......: ');
  149.     WrLngCard(rekursiv(n, k), 0);
  150.     WriteLn;
  151.   ELSIF (ch='n') OR (ch='N') THEN              (* nicht rekursiv *)
  152.     WriteString('Nicht-rekursive Loesung: ');
  153.     WrLngCard(nichtrekursiv(n, k), 0);
  154.     WriteLn;
  155.   ELSE                                         (* beides *)
  156.     WriteString('Rekursive Loesung......: ');
  157.     WrLngCard(rekursiv(n, k) ,0);
  158.     WriteLn;
  159.     WriteString('Nicht-rekursive Loesung: ');
  160.     WrLngCard(nichtrekursiv(n, k), 0);
  161.     WriteLn;
  162.   END;
  163.   WriteLn; WriteLn;
  164.   WriteString('Ende der Berechnung!');
  165.   WriteLn; WriteLn;
  166. END bino.
  167.  
  168.