递归java-测试是两个整数之和相等的布尔函数

我写了一个接受两个整数的递归函数。如果第一个数字等于第二个数字，则函数返回true，否则函数返回false

函数总是返回true

我做错了什么

守则：

public static boolean amountEqual(int num1, int num2) {
    int sum1 = 0, sum2 = 0;

    if (num1 == 0 && num2 == 0 && sum1 == sum2)
        return true;
    else if (num1 == 0 && num2 == 0 && sum1 != sum2)
        return false;

    sum1 += num1 % 10;
    sum2 += num2 % 10;

    return amountEqual(num1 / 10, num2 / 10);
}

谢谢

我做错了什么

您使用的是始终为零的

sum

。您需要找出一种方法来传递您的

sum1

和

sum2

，以便最终调用可以根据之前的所有调用做出决定

一种方法是使用四个参数创建递归函数，并添加两个参数重载以启动递归链：

public static boolean amountEqual(int num1, int num2) {
    return amountEqual(num1, num2, 0, 0);
}
private static boolean amountEqual(int num1, int num2, int sum1, int sum2) {
    ... // your recursive code goes here
}

另一种方法是计算数字差分，即

num1

中的数字之和减去

num2

中的数字之和，如果差分为零，则返回

true

：

public static boolean amountEqual(int num1, int num2) {
    return digitDifferential(num1, num2) == 0;
}
private static int digitDifferential(int num1, int num2) {
    return (num1 != 0 || num2 != 0)
    ? num1%10 - num2%10 + digitDifferential(num1/10, num2/10)
    : 0;
}

我做错了什么

您使用的是始终为零的

sum

。您需要找出一种方法来传递您的

sum1

和

sum2

，以便最终调用可以根据之前的所有调用做出决定

一种方法是使用四个参数创建递归函数，并添加两个参数重载以启动递归链：

public static boolean amountEqual(int num1, int num2) {
    return amountEqual(num1, num2, 0, 0);
}
private static boolean amountEqual(int num1, int num2, int sum1, int sum2) {
    ... // your recursive code goes here
}

另一种方法是计算数字差分，即

num1

中的数字之和减去

num2

中的数字之和，如果差分为零，则返回

true

：

public static boolean amountEqual(int num1, int num2) {
    return digitDifferential(num1, num2) == 0;
}
private static int digitDifferential(int num1, int num2) {
    return (num1 != 0 || num2 != 0)
    ? num1%10 - num2%10 + digitDifferential(num1/10, num2/10)
    : 0;
}

---

首先，你的问题不清楚。我假设，若两个数字的数字和相等，则希望函数返回true

第二，你假设数字的长度相等，但它们可能不是

第三，您没有将

sum1

和

sum2

作为参数传递

更简单的方法是创建两个函数，如下所示：

public static int digitSum(int num) {
    if (num > 0) {
        return num % 10 + digitSum(num / 10);
    }
    else
        return 0;
}

public static boolean amountEqual(int num1, int num2) {
    return digitSum(num1) == digitSum(num2);
}

---

首先，你的问题不清楚。我假设，若两个数字的数字和相等，则希望函数返回true

第二，你假设数字的长度相等，但它们可能不是

第三，您没有将

sum1

和

sum2

作为参数传递

更简单的方法是创建两个函数，如下所示：

public static int digitSum(int num) {
    if (num > 0) {
        return num % 10 + digitSum(num / 10);
    }
    else
        return 0;
}

public static boolean amountEqual(int num1, int num2) {
    return digitSum(num1) == digitSum(num2);
}

---

每次调用AMOUNTQUAL方法时的前两行代码 它用零初始化两个新变量 让我们跟踪您的递归

System.out.println(amountEqual(18,26));
      /* F(20,30) = F(18/10,26/10) [sum1 = 8 , sum2 = 6] 
           re init sum1 = 0 , sum2 =0

            F(1,2)  = F(1/10,2/10) [ sum1 = 1 , sum2 = 2] 
           re init sum1 = 0 , sum2 = 0 
                    F(0,0) = true */

---

每次调用AMOUNTQUAL方法时的前两行代码 它用零初始化两个新变量 让我们跟踪您的递归

System.out.println(amountEqual(18,26));
      /* F(20,30) = F(18/10,26/10) [sum1 = 8 , sum2 = 6] 
           re init sum1 = 0 , sum2 =0

            F(1,2)  = F(1/10,2/10) [ sum1 = 1 , sum2 = 2] 
           re init sum1 = 0 , sum2 = 0 
                    F(0,0) = true */

---

两个变量

sum1

和

sum2

的用途是什么？每个调用都有自己的

sum1

和

sum2

版本。如果不想在调用之间共享状态，请将其作为参数传递。不要急于使用全局/实例vars.sum1=第一个数字的所有数字之和Sum2=第二个数字的所有数字之和这两个变量的用途是什么

sum1

和

Sum2

？每个调用都有自己版本的

sum1

和

Sum2

。如果不想在调用之间共享状态，请将其作为参数传递。不要急于使用全局/实例变量。sum1=第一个数字的所有数字之和Sum2=第二个数字的所有数字之和，如果将

sum1

中的数字添加到

sum

中，则可以将

sum1

和

Sum2

压缩为一个参数

sum

num2

从

sum2

中减去。“但那只是吹毛求疵，”玛格丽特·布鲁姆说，“这是个非常聪明的主意！我提出了另一种方法，它基于计算数字差分并在返回为零时返回

true

。谢谢第二种方法也是我刚刚要提出的，但有一点改进：通过执行

num1<10&&num2<10跳过最后一个递归调用（以及随之而来的额外div/mod计算）？num1-num2:…

FWIW如果将

num1

中的数字添加到

sum

中，并从

sum2

中减去

num2

中的数字，则可以将

sum1

和

sum2

压缩为一个参数

sum

。“但那只是吹毛求疵，”玛格丽特·布鲁姆说，“这是个非常聪明的主意！我提出了另一种方法，它基于计算数字差分并在返回为零时返回

true

。谢谢第二种方法也是我刚刚要提出的，但有一点改进：通过执行

num1<10&&num2<10跳过最后一个递归调用（以及随之而来的额外div/mod计算）？num1-num2:…

为什么

/=

什么时候

/

就是你所需要的通过执行

if（num<10）return num跳过递归他们没有假设两个数字的长度相等。当两个数字都为零时，代码终止，为true，但由于非有效数字为零，因此隐式支持不同长度的数字。为什么
/=
当
/
是您所需要的一切？--通过执行
if（num<10）return num跳过递归他们没有假设两个数字的长度相等。当两个数字都为零时，代码终止，但由于非有效数字为零，因此隐式支持长度不同的数字。