[JAVA] Über die kontinuierliche Teilungsmethode in der 4. Klasse der Grundschule gelernt

Es hat ein mathematisches Tag, aber es ist arithmetisch.

Kontinuierliche Teilungsmethode

In der 4. Klasse der Grundschule lernte ich die maximalen und minimalen gemeinsamen Vielfachen, aber ich lernte, dass es zu dieser Zeit eine kontinuierliche Teilungsmethode (beide Suda-Berechnung) im "How to Do" gibt.

Wie macht man

Maximales Engagement (GCD)

Wenn die Menge der Ganzzahlen einen gemeinsamen Bruch enthält, reduzieren Sie ihn und multiplizieren Sie alle Teiler, um ihn zu finden.

Minimum Common Multiple (LCM)

Wenn ein Satz von ganzen Zahlen zwei oder mehr gemeinsame Brüche enthält, reduzieren Sie diese und multiplizieren Sie dann den Divisor und den Rest.

Gemeinsame GCD, LCM

Natürlich können Sie dies leicht mit euklidischer gegenseitiger Teilung tun. Selbst wenn es mehr als zwei Paare von ganzen Zahlen gibt, kann dies durch $ gcd (a, b, c) = gcd (gcd (a, b), c) $ gelöst werden.

public int gcd(int a, int b) {
   if (b == 0) return a;
   return gcd(b, a % b);
}

public int lcm(int a, int b) {
    return a * b / gcd(a, b);
}

Versuchen Sie erneut zu implementieren

Da der Zweck jedoch darin besteht, in Scratch reproduzierbar zu sein, werde ich versuchen, es vorerst in Java zusammenzustellen. Quelle

--Versuchen Sie, eine Reihe von ganzen Zahlen mit Primzahlen zu reduzieren

Da sich die Vertragsmethode zwischen GCD und LCM unterscheidet, wird Predicate ersetzt. Sie können Funktionen auch in Java übergeben!

Integer primeFactory(List<Integer> intList) {
	Predicate<Integer> op = mode.equals(Mode.GCD) ? factoryAll(intList) : factoryMulti(intList);
	return primeList.stream().filter(op).findFirst().orElse(1);
}

static Predicate<Integer> factoryAll(List<Integer> intList) {
	return i -> intList.stream().allMatch(isDivisable(i));
}

static Predicate<Integer> factoryMulti(List<Integer> intList) {
	return i -> intList.stream().filter(isDivisable(i)).count() > 1;
}

――Wenn Sie einen Vertrag abschließen können, fahren Sie mit der nächsten Stufe fort

Generieren Sie einen neuen Satz von Ganzzahlen, indem Sie den ursprünglichen Satz von Ganzzahlen durch einen Bruch teilen. UnaryOperator übergibt eine Single-Term-Operation. Wenn es aufgrund von LCM nicht teilbar ist, wird die ursprüngliche Ganzzahl zurückgegeben.

static List<Integer> divideList(Integer divisor, List<Integer> intList) {
	return intList.stream().map(divide(divisor)).collect(Collectors.toList());
}

static UnaryOperator<Integer> divide(Integer divisor) {
	return i -> (i % divisor) == 0 ? i / divisor : i;
}

• Multiplizieren Sie schließlich alle Objekte

Integer getGCD() {
	return reduceDivisor();
}
Integer getLCM() {
	return getLastValue().stream().reduce(1, (x, y) -> x * y) * reduceDivisor();
}
Integer reduceDivisor() {
	return stack.stream().map(p -> p.getKey()).reduce(1, (x, y) -> x * y);
}

Nachwort

Es gibt drei Schritte, aber es scheint schwierig zu sein, mit Scratch zu erstellen, daher steht es noch aus. Welches ist die Primzahlableitung?