1-10000 Java之间友好数的递归方法
我在创建一个递归方法来寻找1-10000之间的友好数字时遇到了一个问题。我创建了一个方法来确定两个数字是否友好，但我不知道如何针对每个可能的数字组合运行它。下面是我写的两种方法1-10000 Java之间友好数的递归方法,java,recursion,Java,Recursion,我在创建一个递归方法来寻找1-10000之间的友好数字时遇到了一个问题。我创建了一个方法来确定两个数字是否友好，但我不知道如何针对每个可能的数字组合运行它。下面是我写的两种方法 public void amicable(int n, int m) { int sumM = 0; int sumN = 0; for (int i = 1; i < n; i++) { if (n % i == 0) { sumN += i;
public void amicable(int n, int m) {
int sumM = 0;
int sumN = 0;
for (int i = 1; i < n; i++) {
if (n % i == 0) {
sumN += i;
}
}
for (int j = 1; j < m; j++) {
if (m % j == 0) {
sumM += j;
}
}
if (sumN == m && sumM == n) {
System.out.println(n + " and " + m + " are amicable numbers");
}
}
public static void amicableBetween(int n, int m) {
int sumaM = 0;
int sumaN = 0;
if (m >= 1) {
for (int j = 1; j < m; j++) {
if (m % j == 0) {
sumaM += j;
}
}
for (int i = 1; i < n; i++) {
if (n % i == 0) {
sumaN += i;
}
}
if (sumaN == m && sumaM == n) {
System.out.println(n + " and " + m + " are amicable numbers");
amicableBetween(n + 1, m - 1);
} else {
System.out.println(n + " i " + m + " aren't amicable numbers");
amicableBetween(n + 1, m - 1);
}
}
}
}因此，您编写了一个方法，可以判断两个数字是否友好。这是最困难的部分。你所要做的就是从两个循环中调用它，一个用于上限，一个用于下限
for(lowerNumber = 1; lowerNumber < 10000; lowerNumber++){
for(upperNumber = lowerNumber + 1; upperNumber <= 10000; upperNumber++){
amicable(lowerNumber, upperNumber);
}
}
所以，你写了一个方法，可以判断两个数字是否友好。这是最困难的部分。你所要做的就是从两个循环中调用它，一个用于上限，一个用于下限
for(lowerNumber = 1; lowerNumber < 10000; lowerNumber++){
for(upperNumber = lowerNumber + 1; upperNumber <= 10000; upperNumber++){
amicable(lowerNumber, upperNumber);
}
}
小免责声明，此方法可能会花费很长时间，并且可能会耗尽堆栈空间，因此我不能100%确定递归计算1-10000之间的所有友好数字是正确的方法。如果这只是为了好玩或练习，那么我想是可以的 一种方法是扫描n，直到我们到达m-1，并在每一步调用友好n，m。一旦n达到m-1，我们可以将m减少1，然后重复这个过程，直到n等于m-1，然后我们检查了所有可能的组合。要做到这一点，可以将两种方法分解为三种方法 第一个方法是您已经拥有的友好方法，只是更改了返回类型，以便我们在递归链中可以重用它：
public static boolean amicable(int n, int m) {
int sumM = 0;
int sumN = 0;
for (int i = 1; i < n; i++) {
if (n % i == 0) {
sumN += i;
}
}
for (int j = 1; j < m; j++) {
if (m % j == 0) {
sumM += j;
}
}
return sumN == m && sumM == n;
}
private static void amicableBetween(int n, int m, boolean start) {
if(n == m) {
return;
}
if (m >= 1) {
if (amicable(n, m)) {
System.out.println(n + " and " + m + " are amicable numbers");
} else {
System.out.println(n + " and " + m + " aren't amicable numbers");
}
amicableBetween(n + 1, m, false);
}
if(start) {
amicableBetween(n, m - 1, true);
}
}
小免责声明，此方法可能会花费很长时间，并且可能会耗尽堆栈空间，因此我不能100%确定递归计算1-10000之间的所有友好数字是正确的方法。如果这只是为了好玩或练习，那么我想是可以的 一种方法是扫描n，直到我们到达m-1，并在每一步调用友好n，m。一旦n达到m-1，我们可以将m减少1，然后重复这个过程，直到n等于m-1，然后我们检查了所有可能的组合。要做到这一点，可以将两种方法分解为三种方法 第一个方法是您已经拥有的友好方法，只是更改了返回类型，以便我们在递归链中可以重用它：
public static boolean amicable(int n, int m) {
int sumM = 0;
int sumN = 0;
for (int i = 1; i < n; i++) {
if (n % i == 0) {
sumN += i;
}
}
for (int j = 1; j < m; j++) {
if (m % j == 0) {
sumM += j;
}
}
return sumN == m && sumM == n;
}
private static void amicableBetween(int n, int m, boolean start) {
if(n == m) {
return;
}
if (m >= 1) {
if (amicable(n, m)) {
System.out.println(n + " and " + m + " are amicable numbers");
} else {
System.out.println(n + " and " + m + " aren't amicable numbers");
}
amicableBetween(n + 1, m, false);
}
if(start) {
amicableBetween(n, m - 1, true);
}
}
我想知道你为什么想要递归算法。你不担心StackOvervlowException吗？！使用简单的地图很容易在规定时间内找到：
我想知道你为什么想要递归算法。你不担心StackOvervlowException吗？！使用简单的地图很容易在规定时间内找到：
我不知道为什么在友好函数中需要两个参数。友好数具有周期2的重复等分序列，这意味着
s(s(n)) == n
控制台。记录“友好！”，n、 s_n 我不知道为什么在友好函数中需要两个参数。友好数具有周期2的重复等分序列，这意味着
s(s(n)) == n
控制台。记录“友好！”，n、 s_n；请阅读并相应地强化您的问题。您的问题缺少清晰的问题描述。请阅读并相应增强您的问题。您的问题缺少清晰的问题描述。谢谢，但我不能在递归方法中使用它获取StackOverflowerError。对于这个例子，最重要的是使用递归。谢谢你，但是我不能告诉我们
使用递归方法获取StackOverflowerError。对于这个例子来说，最重要的是使用递归。是的，这是我需要的，但是时间太长，有时会导致堆栈溢出。但无论如何，谢谢你。是的，这正是我所需要的，但时间太长，有时会溢出。但无论如何，谢谢你。谢谢，这是我找到的最快的解决方案。但仍然没有递归。谢谢，这是我找到的最快的解决方案。但仍然没有递归。