Rationale Zahlen (Zahlen, die in Form von ganzen Zahlen / ganzen Zahlen dargestellt werden können) können immer entweder durch endliche oder kreisförmige Brüche dargestellt werden. Im Gegenteil, endliche Brüche und kreisförmige Brüche können immer in Form rationaler Zahlen ausgedrückt werden.
Beispiel 3/4 = 0.75 1/7 = 0.142857142857... = 0.(142857) (Der zirkulierende Teil des kreisförmigen Bruchs wird als kreisförmiger Knoten bezeichnet und durch Punkte auf der ersten und letzten Zahl des kreisförmigen Knotens dargestellt. Zirkelsätze sind in Klammern eingeschlossen. )
Ich wollte eine beliebige rationale Zahl als einen Bruch ausdrücken, der nicht in der Mitte abschneidet, also habe ich eine Klasse erstellt, die eine rationale Zahl darstellt. Als eine der Methoden habe ich eine Methode erstellt, die "eine gebrochene Notation ausgibt, die als Zirkelsatz aus einer rationalen Zahl ausgedrückt werden kann". Außerdem habe ich als eine der Factory-Methoden eine Methode erstellt, die eine gebrochene Zeichenfolge mit einem zirkulären Satzausdruck empfängt und in eine rationale Zahl konvertiert.
Die Felder der rationalen Zahlenklasse sind Molekül: Molekül, langer Typ Nenner: Nenner, langer Typ Und sagte. Außerdem haben wir beschlossen, die Codeelemente zu vereinheitlichen und im Molekül zu haben, und sie zu invarianten Klassen in Form von irreduziblen Brüchen gemacht. Wenn es eine ganze Zahl ist, habe ich beschlossen, sie in Form von 1 im Nenner zu haben.
Machen Sie rationale Zahlen zu Brüchen
public String toDecimalString() {
//Wenn es sich um eine Ganzzahl handelt, wird sie unverändert angezeigt
if (denominator == 1L)
return String.valueOf(molecule);
//Teilen Sie in der Art des Schreibens. Nehmen Sie zuerst den ganzzahligen Teil heraus
LinkedHashMap<Long, Long> restAndDigit = new LinkedHashMap<>();
long integer = Math.abs(molecule) / denominator;
long remind = Math.abs(molecule) % denominator;
//Wiederholen Sie die Teilung, bis derselbe Rest wie der oben genannte Rest erscheint oder teilbar ist.
while (!restAndDigit.containsKey(remind) && remind != 0L) {
long r = remind * 10L;
restAndDigit.put(remind, r / denominator);
remind = r % denominator;
}
StringBuilder builder = new StringBuilder();
if (molecule < 0L)
builder.append('-');
builder.append(integer).append('.');
//Wenn es teilbar ist, zeigen Sie alle Ziffern nebeneinander an
if (remind == 0L) {
restAndDigit.values().forEach(builder::append);
return builder.toString();
}
Iterator<Map.Entry<Long, Long>> iterator = restAndDigit.entrySet().iterator();
Map.Entry<Long, Long> temp;
while (!(temp = iterator.next()).getKey().equals(remind)) {
builder.append(temp.getValue());
}
builder.append('(').append(temp.getValue());
iterator.forEachRemaining(e -> builder.append(e.getValue()));
return builder.append(')').toString();
}
Konvertieren der gebrochenen Notation in rationale Zahlen
public static Fraction2 parseDecimal(String str) {
Matcher matcher = Pattern.compile("(-?\\d+\\.\\d*)(\\(\\d+\\))?").matcher(str);
if (!matcher.matches())
throw new NumberFormatException("Illegal input : " + str);
BigDecimal decimal = new BigDecimal(matcher.group(1));
if (matcher.group(2) == null)
return fromDecimal(decimal);
BigInteger m1 = decimal.unscaledValue();
BigInteger d1 = TEN.pow(decimal.scale());
BigDecimal decimal2 = new BigDecimal(matcher.group().replaceAll("[\\(\\)]", ""));
BigInteger m2 = decimal2.unscaledValue();
BigInteger d2 = TEN.pow(decimal2.scale());
//Eine andere Methode, um mit BigInteger eine rationale Zahl zu erstellen
return fromBigInteger(m2.subtract(m1), d2.subtract(d1));
}
Ursprünglich wurde das Nennermolekül mit BigInteger hergestellt und unbeaufsichtigt gelassen, aber ich habe es zu lange umgeschrieben, um zu denken, dass "eine große Anzahl nicht zum Nennermolekül kommt", aber ich mache mir Sorgen über einen Überlauf aufgrund von Addition und Multiplikation Ich erinnerte mich, dass ich BigInteger verwendete, weil es schwierig war, orz zu starten