Un algorithme qui trouve le maximum de promesses de deux nombres naturels.
Pour le dire simplement
a % b = r
b % r = s
r % s = 0
Sous la forme de, le nombre à diviser est le prochain nombre à diviser, et le reste est le prochain nombre à diviser, et ceci est répété de manière récursive. Le nombre à diviser lorsque le reste devient 0 (s dans l'exemple ci-dessus) est l'engagement maximum des nombres naturels a et b.
package com.company;
import java.io.*;
class Main {
public static void main(String[] args) {
try {
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
String[] str = bufferedReader.readLine().split(" ");
int x = Integer.parseInt(str[0]);
int y = Integer.parseInt(str[1]);
System.out.println(getCommonDivisor(x, y));
} catch (Exception e) {
System.out.println(e);
}
}
private static int getCommonDivisor(int x, int y) {
int biggerNum = Math.max(x, y);
int smallerNum = Math.min(x, y);
//Trouvez le reste de la division du plus petit du plus grand
int surplus = biggerNum % smallerNum;
//S'il est divisible, retournez-le
if (surplus == 0) {
return smallerNum;
}
//S'il n'est pas divisible, il appelle récursivement à la confiance
surplus = getCommonDivisor(smallerNum, surplus);
return surplus;
}
}
//contribution
390 273
//production
39
Le code ci-dessus à l'origine ne pensait pas profondément à l'entrée, etc., juste implémenté l'algorithme, donc il ne considère pas la gestion des exceptions, etc. et il tombe facilement.
Par conséquent, j'ai écrit un nouveau code qui reflète le commentaire reçu de @ saka1029. Merci, @ saka1029.
Cette fois, le code est écrit dans les conditions suivantes.
Les nombres négatifs sont retournés à l'entrée avec la mise en œuvre de la division mutuelle euclidienne.
Même si quelque chose d'autre que des nombres est entré, il ne tombera pas
De plus, il existe des écoles qui incluent 0 en nombres naturels et des écoles qui n'incluent pas 0 en nombres naturels, mais cette fois, nous adopterons des "écoles qui n'incluent pas 0 en nombres naturels".
package com.company;
import java.io.*;
class Main {
private static int x = -1;
private static int y = -1;
private static final String caution = "Veuillez saisir deux nombres naturels séparés par des espaces demi-largeur.(Cependant, 0 n'est pas naturellement inclus dans ce programme.)";
public static void main(String[] args) {
System.out.println(caution);
readInput();
System.out.println(doEuclideanAlgorithm(x, y));
}
private static void readInput() {
try {
while (x <= 0 || y <= 0) {
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
String[] str = bufferedReader.readLine().split(" ");
x = Integer.parseInt(str[0]);
y = Integer.parseInt(str[1]);
if (x <= 0 || y <= 0) {
System.out.println("L'entrée est incorrecte." + caution);
}
}
} catch (Exception e) {
System.out.println("L'entrée est incorrecte." + caution);
readInput();
}
}
private static int doEuclideanAlgorithm(int x, int y) {
int biggerNum = Math.max(x, y);
int smallerNum = Math.min(x, y);
//Trouvez le reste de la division du plus petit du plus grand
int surplus = biggerNum % smallerNum;
//S'il est divisible, retournez-le
if (surplus == 0) {
return smallerNum;
}
//S'il n'est pas divisible, il appelle récursivement à la confiance
surplus = doEuclideanAlgorithm(smallerNum, surplus);
return surplus;
}
}
Veuillez saisir deux nombres naturels séparés par des espaces demi-largeur.(Cependant, 0 n'est pas naturellement inclus dans ce programme.)
a a
L'entrée est incorrecte. Veuillez saisir deux nombres naturels séparés par des espaces demi-largeur.(Cependant, 0 n'est pas naturellement inclus dans ce programme.)
390 0
L'entrée est incorrecte. Veuillez saisir deux nombres naturels séparés par des espaces demi-largeur.(Cependant, 0 n'est pas naturellement inclus dans ce programme.)
0 273
L'entrée est incorrecte. Veuillez saisir deux nombres naturels séparés par des espaces demi-largeur.(Cependant, 0 n'est pas naturellement inclus dans ce programme.)
-390 273
L'entrée est incorrecte. Veuillez saisir deux nombres naturels séparés par des espaces demi-largeur.(Cependant, 0 n'est pas naturellement inclus dans ce programme.)
390 -273
L'entrée est incorrecte. Veuillez saisir deux nombres naturels séparés par des espaces demi-largeur.(Cependant, 0 n'est pas naturellement inclus dans ce programme.)
390 273
39
Si vous avez quelque chose comme "C'est étrange ici" ou "Je peux le rendre plus intelligent", je vous serais reconnaissant si vous pouviez commenter.
Comme vous l'avez dit dans le commentaire de @ howdy39, il y avait quelques subtilités. Merci, @ howdy39. Voici le code intelligent qui a adopté le point de @ howdy39.
Je n'avais pas besoin d'une instruction while car j'exécutais récursivement readInput () quand il y avait une exception.
package com.company;
import java.io.*;
class Main {
private static final String caution = "Veuillez saisir deux nombres naturels séparés par des espaces demi-largeur.(Cependant, 0 n'est pas naturellement inclus dans ce programme.)";
public static void main(String[] args) {
System.out.println(caution);
int[] inputs = readInput();
System.out.println(doEuclideanAlgorithm(inputs[0], inputs[1]));
}
private static int[] readInput() {
try {
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
String[] str = bufferedReader.readLine().split(" ");
int x = Integer.parseInt(str[0]);
int y = Integer.parseInt(str[1]);
if (x <= 0 || y <= 0) {
throw new Exception("");
}
return new int[]{x, y};
} catch (Exception e) {
System.out.println("L'entrée est incorrecte." + caution);
return readInput();
}
}
private static int doEuclideanAlgorithm(int x, int y) {
int biggerNum = Math.max(x, y);
int smallerNum = Math.min(x, y);
//Trouvez le reste de la division du plus petit du plus grand
int surplus = biggerNum % smallerNum;
//S'il est divisible, retournez-le
if (surplus == 0) {
return smallerNum;
}
//S'il n'est pas divisible, il appelle récursivement à la confiance
surplus = doEuclideanAlgorithm(smallerNum, surplus);
return surplus;
}
}
Veuillez saisir deux nombres naturels séparés par des espaces demi-largeur.(Cependant, 0 n'est pas naturellement inclus dans ce programme.)
a a
L'entrée est incorrecte. Veuillez saisir deux nombres naturels séparés par des espaces demi-largeur.(Cependant, 0 n'est pas naturellement inclus dans ce programme.)
390 0
L'entrée est incorrecte. Veuillez saisir deux nombres naturels séparés par des espaces demi-largeur.(Cependant, 0 n'est pas naturellement inclus dans ce programme.)
0 273
L'entrée est incorrecte. Veuillez saisir deux nombres naturels séparés par des espaces demi-largeur.(Cependant, 0 n'est pas naturellement inclus dans ce programme.)
-390 273
L'entrée est incorrecte. Veuillez saisir deux nombres naturels séparés par des espaces demi-largeur.(Cependant, 0 n'est pas naturellement inclus dans ce programme.)
390 -273
L'entrée est incorrecte. Veuillez saisir deux nombres naturels séparés par des espaces demi-largeur.(Cependant, 0 n'est pas naturellement inclus dans ce programme.)
390 273
39
Recommended Posts