ADS - Euklid

Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

  • ADS - Euklid

    Servus...

    hier eine mögliche Lösung...

    Also ich bekomme einen BufferOverFlowError bei der Rekursion ohne Modulo, ich denke es liegt an den zu großen Zahlen in der Input-Datei.

    Quellcode

    1. package u1;
    3. import fhw.*;
    5. public class A5 {
    7. // Standard-Modus: false
    8. // Sicherer-Modus: true (andere Ergebnise)
    9. static boolean BufferOverFlowSave = true;
    10. // Maximale Zahl
    11. static int BufferBorder = 20000;
    13. public static void main (String args[]) {
    15. int zahlen[] = ADSTool.readIntArray("u1a4.dat") ;
    16. int teiler;
    17. int nenner;
    18. int summe;
    19. int anz;
    21. String methode = "";
    23. for(int j = 1; j <= 4; j++) {
    25. summe = 0;
    26. anz = 0;
    27. ADSTool.resetTime();
    29. for(int i = 0; i < zahlen.length; i++) {
    30. if(i%2 == 0 && i < zahlen.length - 1) {
    32. if(BufferOverFlowSave) {
    33. teiler = zahlen[i] > BufferBorder ? BufferBorder : zahlen[i];
    34. nenner = zahlen[i+1] > BufferBorder ? BufferBorder : zahlen[i+1];
    35. }
    36. else {
    37. teiler = zahlen[i];
    38. nenner = zahlen[i+1];
    39. }
    41. switch(j) {
    42. case 1:
    43. summe += ggT_iterativ (teiler, nenner);
    44. anz++;
    45. break;
    46. case 2:
    47. if(BufferOverFlowSave) {
    48. summe += ggT_rekursiv (teiler, nenner);
    49. anz++;
    50. }
    51. break;
    52. case 3:
    53. summe += ggT_iterativ_modulo (teiler, nenner);
    54. anz++;
    55. break;
    56. case 4:
    57. summe += ggT_rekursiv_modulo (teiler, nenner);
    58. anz++;
    59. break;
    60. }
    62. }
    63. }
    65. switch (j) {
    66. case 1: methode = "ggT (iterativ)"; break;
    67. case 2: methode = "ggT (rekursiv)"; break;
    68. case 3: methode = "ggT (iterativ mit Modulo)"; break;
    69. case 4: methode = "ggT (rekursiv mit Modulo)"; break;
    70. }
    72. if(BufferOverFlowSave || (!BufferOverFlowSave && j != 2)) {
    73. System.out.print("==============================\n");
    74. System.out.printf("Verwendeter Algorithmus: %s\n", methode);
    75. System.out.printf("Ergebnis: %d\n",summe/anz);
    76. System.out.printf("Zeitmessung: %s\n\n",ADSTool.stringRTime());
    77. }
    78. }
    79. }
    81. /**
    82. * ggT - iterativ
    83. * @param x > 0
    84. * @param y > 0
    85. * @return ggT
    86. */
    88. public static int ggT_iterativ (int x, int y) {
    89. while(x != y) {
    90. if(x < y) {
    91. int t = x;
    92. x = y;
    93. y = t;
    94. }
    95. x = x - y;
    96. }
    97. return x;
    98. }
    100. /**
    101. * ggT - rekursiv
    102. * @param x > 0
    103. * @param y > 0
    104. * @return ggT
    105. */
    107. public static int ggT_rekursiv (int x, int y) {
    108. if(x == y) return x;
    109. if(x < y) return ggT_rekursiv(y - x, x);
    110. return ggT_rekursiv(x - y, y);
    111. }
    113. /**
    114. * ggT - iterativ mit Modulo
    115. * @param x > 0
    116. * @param y > 0
    117. * @return ggT
    118. */
    120. public static int ggT_iterativ_modulo (int x, int y) {
    121. while(x != y) {
    122. int t = x;
    123. x = y;
    124. y = t % y;
    125. if(y == 0) return x;
    126. }
    127. return x;
    128. }
    130. /**
    131. * ggT - rekursiv mit Modulo
    132. * @param x > 0
    133. * @param y > 0
    134. * @return ggT
    135. */
    137. public static int ggT_rekursiv_modulo (int x, int y) {
    138. if(y != 0) return ggT_rekursiv_modulo(y, x % y);
    139. return x;
    140. }
    141. }
    Alles anzeigen