Question

我遇到了涉及递归的练习

问题：

写一个递归函数，它返回一个整数，＆＃34;校验位＆＃34;。通过计算传入整数中所有数字的总和来计算该校验位。但是，如果结果大于或等于10（即，大于一个数字），则应使用结果作为输入再次执行计算。因此，直到返回的最终数字将是一个数字;这个数字是＆＃34;校验位＆＃34;。

示例：

号码869419 ----＆gt; 8 + 6 + 9 + 4 + 1 + 9 = 37 - ＆gt; 3 + 7 = 10 - ＆gt; 1。

*我已经达成的最贴近的解决方案：*

public static int Bik (int n) {
    int sum=0;
    if (n/10 == 1 || n==1) {
        return 1;
    }
    else {
        if (n%10 != 0) {
            return Bik((n/10) + (n%10));
        }
        return (n);
    }
}

public static void main(String[] args) {
    System.out.println(Bik(1892));
}

Answer 1

您在Bik方法的第1行遇到一个问题：

每次调用它时，变量sum都定义为0，因此它永远不会改变。同样在您的代码中，您实际上从未对上一次迭代中的值求和。我可以提供的解决方案是使用前一次迭代的总和传递另一个参数：

public static int Bik (int n, int sum) {
    // You get the value of the last digit and sum it to your total
    sum += n%10;
    // This validation is to know if there is only 1 digit left  
    if (n>9) 
        // The required recursion
        return Bik(n/10, sum); 
    //In case the sum is higher than 9 the recursion is called again, otherwise it returns the sum
    return sum>9 ? Bik(sum, 0) : sum;
}

public static void main(String[] args) {
    System.out.println(Bik(1892, 0));
}

请注意，此解决方案也适用于递归必须像189235一样运行多次的数字。此外，我使用了三元运算符。您可以了解有关它的更多信息here但如果您不喜欢它，您也可以使用常规if声明

Answer 2

首先，您需要检查输入是否大于10，否则只返回输入。

if(input < 10) { //no computation required return input
     return input;
}

然后，如果输入大于10.您需要获取组成输入的每个数字。要获得一个数字，只需模10 input%10。这将为您提供最后一位数字。然后将输入除以10并重新操作以获得下一个数字。重复此操作，直到输入低于10.这里您已获得所有数字

while(input > 9) { // until input is lower than 10
    int newDigit = input % 10; //find a digit
    digits.add(Integer.valueOf(newDigit);  //ass it to a list
    input /= 10;  //reduce input
}
digits.add(Integer.valueOf(input)); //add the last input digit

必须对列表中的所有元素求和以获得结果

for(Integer i : digits) { //sum all digits
    result += i;
}

最后返回此结果的计算结果。通过这样做你使用递归，如果结果低于10它将返回，如果它更大它将再次计算。

return compute(result); // return the computed result

这些步骤的总和应该是：

public int compute(int input) {
    if(input < 10) { //no computation required return input
         return input;
    } else {
        List<Integer> digits = new ArrayList<Interger>(); //will contains the digit composing input
        int inComputationInt = input; //a copy of input that will be modified
        int result = 0; //the resulting sum of digit

        while(inComputationInt > 9) { //obtain every digit in input
            int newDigit = inComputation % 10;
            digits.add(Integer.valueOf(newDigit));
            inComputation /= 10;
        }
        digits.add(Integer.valueOf(inComputation);

        for(Integer i : digits) { //sum all digits
            result += i;
        }

        return compute(result); // return the computation of result
    }
}

Answer 3

编辑后 - 现在更加清晰。

int checkDigit(int n) {
    // Any single-digit is the check digit.
    if (n < 10) return n;
    // More than one digit - add them up.
    String digits = Integer.toString(n);
    int sum = 0;
    for (int i = 0; i < digits.length(); i++) {
        sum += digits.charAt(i) - '0';
    }
    // Check that sum.
    return checkDigit(sum);
}

private void test(int n) {
    System.out.println("Check difgit for "+n+" = "+checkDigit(n));
}

public void test(String[] args) {
    int[] tests = {86941,869419,189,1892};
    for(int n: tests) {
        test(n);
    }
}

Answer 4

public int digitSum(int n) {
 if(n < 10) return n;
 return n % 10 + digitSum(n / 10);
}

首先，您需要一个基本案例，在这种情况下，这是您提供的数字，如果小于10，则返回给定的数字。

第二个return语句采用最右边的数字（取模数n％10）并将其保存到堆栈中，然后再次调用该方法，但使用（n / 10），该计算将删除最右边的数字，因为您已经使用过它在模数计算中，因此您不再需要它。将新数字传递给方法，然后重复此过程，直到您的数字小于10。

希望这可以澄清一点。

Answer 5

将此方法包含在您的代码中，将数字传递给digitSum

static int digitSum(int n)
{
    int sum = 0;

    // Loop to do sum while
    // sum is not less than
    // or equal to 9
    while (n > 0 || sum > 9) 
    {
        if (n == 0) {
            n = sum;
            sum = 0;
        }
        sum += n % 10;
        n /= 10;
    }
    return sum;
}

Java - 使用支票号进行递归求解

5 个答案: