Prüfen, ob eine Zahl eine periodische Zahl ist

sserio

Bekanntes Mitglied
Wie im Titel schon steht, möchte ich wissen, ob man irgendwie herausfinden kann, ob eine Zahl eine periodische Zahl ist und was die Periode ist.
Bsp.: 1,67676767 dann ist die Periode 67 nach der 1, . Ich habe mir gedacht, dass man vielleicht 50(+) Nachkommastellen überprüfen könnte und bestimmte Intervalle der Zahl mithilfe von Substrings vergleichen könnte. Habt ihr andere Ideen.
 
Eine Folge/ Muster kann ich auch nicht erkennen (vllt. gerade und ungerade Ziffern), weil 1/6 auch eine periodische Ziffer ergibt, genauso wie die Ungeraden.

1/2= 0.5
1/3= 0.(3)
1/4= 0.25
1/5= 0.2
1/6= 0.1(6)
1/7= 0.(142857)
1/8= 0.125
1/9= 0.(1)
1/10= 0.1
 
Eine periodische Zahl ist ja gerade eine Zahl, die sich nicht dezimal darstellen lässt, wie z.B. 1/3.
Du willst also aus einer dezimalen Darstellung einer Zahl ermitteln, ob die Zahl eine Periode (in ihrer (undendlichen) dezimalen Darstellung) hätte?
Und wenn ich dir die dezimale Zahl: 0,3333333 gebe und dir sage, dass ich _wirklich_ die dezimale Zahl 0,3333333 meine und _nicht_ den Quotient 1/3 ?

In welcher Form ist die Zahl denn gegeben? Kann ja nur als Bruch sein.
 
Eine periodische Zahl ist ja gerade eine Zahl, die sich nicht dezimal darstellen lässt, wie z.B. 1/3.
Du willst also aus einer dezimalen Darstellung einer Zahl ermitteln, ob die Zahl eine Periode (in ihrer (undendlichen) dezimalen Darstellung) hätte?
Und wenn ich dir die dezimale Zahl: 0,3333333 gebe und dir sage, dass ich _wirklich_ die dezimale Zahl 0,3333333 meine und _nicht_ den Quotient 1/3 ?

In welcher Form ist die Zahl denn gegeben? Kann ja nur als Bruch sein.
Es macht ja keinen Unterschied, ob es jetzt _33333_ ist oder nur _3_ , weil die Stammzahl die sich immer wiederholt 3 ist. Oder?
 
Ach egal. Sagen wir mal ich rechne jetzt so:
Java:
for(int i= 2;i<1000;i++){
    number = 1/i;
}
und ich möchte wissen ,ob dann number eine periodische zahl ist oder nicht und wenn es eine periodische zahl ist, dann die periode herrausfinden
ich komme aber nicht darauf, wie man das überhaupt erst herausfindet.
 
den ersten artikel gelesen und nix verstanden (die zeichen). Mathematisch bin ich glaube ich noch nicht so weit
und wie soll man den schmarrn überhaupt implementieren
 
Was mir spontan einfällt:
Java:
        try {
            final BigDecimal a = new BigDecimal("1.0");
            final BigDecimal b = new BigDecimal("3.0");
            a.divide(b);
        } catch (final ArithmeticException e) {
            if (e.getMessage().contains("Non-terminating decimal expansion")) {
                System.out.println("infinity precision");
            }
            System.out.println("no infinity precision");
        }
 
Das würde ich wie bei einer Schriftlichen Division lösen:

1. Bei 1/n hat du zunächst den Rest 1; den merkst du dir in einer Liste.
2. Dann multiplizierst du den alten Rest mit 10 und berechnest das Ergebnis modulo n.
3. Ist der neue Rest null, so bist du fertig und hast keine Periode.
4. Ist der neue Rest in der Liste enthalten, so hast du eine Periode und bist ebenfalls fertig.
5. Ansonsten füge den neuen Rest der Liste hinzu und fahre mit Punkt 2 fort.

Spätestens nach n Schleifenduchläufen bist du fertig.
 
Um meine Lösung noch einmal zu verdeutlichen, hier zwei Beispiele:
Code:
 1 : 7 = 0,142857
-0
 --
 10                      (Rest 1)
 -7
 ---
  30                     (Rest 3)
 -28
  ---
   20                    (Rest 2)
  -14
   ---
    60                   (Rest 6)
   -56
    ---
     40                  (Rest 4)
    -35
     ---
      50                 (Rest 5)
     -49
      --
       1                 (Rest 1, ist bereits vorgekommen)


 1 : 6 = 0,16
-0
 --
 10                      (Rest 1)
 -6
 ---
  40                     (Rest 4)
 -36
  --
   4                     (Rest 4, ist bereits vorgekommen)
 
Ich weiß, fertiger Code ist doof, aber hier mal ein Beispiel (implementiert die Long Division wie von @fhoffmann vorgeschlagen) und gibt die non-repeating decimal digits und die repeating digits aus:
Java:
import java.util.*;
public class DecimalExpansion {
    public static class Result {
        public final String nonRepeatingFraction;
        public final String repeatingFraction;
        private Result(String nonRepeatingFraction, String repeatingFraction) {
            this.nonRepeatingFraction = nonRepeatingFraction;
            this.repeatingFraction = repeatingFraction;
        }
    }

    public static Result rationalNumberToDecimal(int a, int b) {
        StringBuilder decimalExpansion = new StringBuilder();
        Map<Integer, Integer> remainderToPosition = new HashMap<>();
        int remainder = a % b;
        while (!remainderToPosition.containsKey(remainder)) {
            if (remainder == 0)
                return new Result(decimalExpansion.toString(), "");
            remainderToPosition.put(remainder, decimalExpansion.length());
            remainder *= 10;
            decimalExpansion.append(remainder / b);
            remainder %= b;
        }
        int positionOfRepeatingPart = remainderToPosition.get(remainder);
        return new Result(decimalExpansion.substring(0, positionOfRepeatingPart),
                          decimalExpansion.substring(positionOfRepeatingPart));
    }

    // Test
    public static void main(String[] args) {
        int a = 1;
        int b = 24;

        Result res = rationalNumberToDecimal(a, b);
        System.out.println("Number: 0." + res.nonRepeatingFraction + res.repeatingFraction);
        if (res.repeatingFraction.length() > 0) {
            System.out.println("Non-repeating part: " + res.nonRepeatingFraction);
            System.out.println("Repeating part: " + res.repeatingFraction);
        } else {
            System.out.println("non-repeating");
        }
    }
}
 
Ich weiß, fertiger Code ist doof, aber hier mal ein Beispiel (implementiert die Long Division wie von @fhoffmann vorgeschlagen) und gibt die non-repeating decimal digits und die repeating digits aus:
Java:
import java.util.*;
public class DecimalExpansion {
    public static class Result {
        public final String nonRepeatingFraction;
        public final String repeatingFraction;
        private Result(String nonRepeatingFraction, String repeatingFraction) {
            this.nonRepeatingFraction = nonRepeatingFraction;
            this.repeatingFraction = repeatingFraction;
        }
    }

    public static Result rationalNumberToDecimal(int a, int b) {
        StringBuilder decimalExpansion = new StringBuilder();
        Map<Integer, Integer> remainderToPosition = new HashMap<>();
        int remainder = a % b;
        while (!remainderToPosition.containsKey(remainder)) {
            if (remainder == 0)
                return new Result(decimalExpansion.toString(), "");
            remainderToPosition.put(remainder, decimalExpansion.length());
            remainder *= 10;
            decimalExpansion.append(remainder / b);
            remainder %= b;
        }
        int positionOfRepeatingPart = remainderToPosition.get(remainder);
        return new Result(decimalExpansion.substring(0, positionOfRepeatingPart),
                          decimalExpansion.substring(positionOfRepeatingPart));
    }

    // Test
    public static void main(String[] args) {
        int a = 1;
        int b = 24;

        Result res = rationalNumberToDecimal(a, b);
        System.out.println("Number: 0." + res.nonRepeatingFraction + res.repeatingFraction);
        if (res.repeatingFraction.length() > 0) {
            System.out.println("Non-repeating part: " + res.nonRepeatingFraction);
            System.out.println("Repeating part: " + res.repeatingFraction);
        } else {
            System.out.println("non-repeating");
        }
    }
}
Hä, wieso fragst du bei rationalNumberToDecimal(); ob remainder == 0 . Macht das nicht eingentlich wenig Sinn
 

Zurück
Oben