Il a une balise mathématique, mais c'est de l'arithmétique.

Méthode de division continue

En 4e année du primaire, j'ai appris les multiples communs maximum et minimum, mais j'ai appris qu'il existe une méthode de division continue (les deux calculs suda) dans le «comment faire» à ce moment-là.

Comment faire

Engagement maximum (GCD)

S'il y a une fraction commune dans l'ensemble des entiers, réduisez-la et multipliez tous les diviseurs pour la trouver.

Multiple commun minimum (LCM)

S'il y a deux fractions communes ou plus dans un ensemble d'entiers, réduisez-les, puis multipliez le diviseur et le reste pour le trouver.

GCD commun, LCM

Bien sûr, vous pouvez facilement le faire avec la division mutuelle euclidienne. Même s'il y a plus de deux paires d'entiers, cela peut être résolu par $ gcd (a, b, c) = gcd (gcd (a, b), c) $.

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);
}

Essayez de réimplémenter

Cependant, comme le but est d'être reproductible dans Scratch, je vais essayer de l'assembler en Java pour le moment. Source

Essayez de réduire un ensemble d'entiers avec des nombres premiers

Étant donné que la méthode de passation de marchés est différente entre GCD et LCM, Predicate est remplacé. Vous pouvez également transmettre des fonctions en Java!

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;
}

――Si vous pouvez conclure un contrat, passez à l'étape suivante

Générez un nouvel ensemble d'entiers en divisant l'ensemble d'origine d'entiers par une fraction. Vous passez une opération à un seul terme dans UnaryOperator. S'il n'est pas divisible en raison de LCM, l'entier d'origine est renvoyé.

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;
}

Multipliez enfin tous les objets

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);
}

Épilogue

Il y a trois étapes, mais cela semble difficile à construire avec Scratch, donc il est en attente. Quelle est la dérivation du nombre premier?

[JAVA] À propos de la méthode de division continue apprise en 4e année du primaire