使用递归的数字总和/数字根

Question

我正在尝试使用以下代码添加数字。例如，如果我的输入是 678，我的输出应该是 3.

例如

digital_root(942)
=> 9 + 4 + 2
=> 15 ...
=> 1 + 5
=> 6

    package codewars;

        public class test {

            static int sum(int s)
            {
                int n=s;
                 int add=0;
                 while(n%10 > 0)        
                 {
                     add=n%10 +add;
                     n=n/10;
                     //System.out.println("num is "  +n );
                 }

                if(add/10 > 0)
                {
                    System.out.println(add);
                    sum(add);
                    System.out.println("if block");
                }


                    return add;


            }

            public static void main(String[] args) 
            {
             int result=   test.sum(678);
             System.out.println(result);



            }

          }

我想递归调用求和函数，直到求和只包含一位数。

Answer 1

您可以尝试以下代码 -

public class DigitalRoot{

    public static void main(String[] args){

        System.out.println("Digital Root 9: "+findDigitalRoot(9));
        System.out.println("Digital Root 942: "+findDigitalRoot(942));
        System.out.println("Digital Root 1942: "+findDigitalRoot(1942));
        System.out.println("Digital Root 1876: "+findDigitalRoot(1876));
    }

    public static int findDigitalRoot(int n) {

        if(n>10){

            int sum = n%10 + findDigitalRoot(n/10);
            if(sum>10){
                return findDigitalRoot(sum);
            }else{
                return sum;
            }
        }else{
            return n;
        }       
    }
}

Answer 2

更接近您自己的算法的东西。但是不在任何地方使用 mod ，而是将数字转换为字符串，并在每次传递时将字符的所有数值加在一起。更容易理解，但可能性能不佳（？待测试）。

public class Test{

            static int sum(final int s)
            {
                final String numbers = String.valueOf(s);
                final int amountOfDigits = numbers.length();
                int sum = Character.getNumericValue(numbers.charAt(0));
                for(int i = 1; i < amountOfDigits; i++) {
                    sum += Character.getNumericValue(numbers.charAt(i));
                }

                if(sum > 9) {
                    return sum(sum);    
                } else {
                    return sum;
                }
            }

            public static void main(String[] args) 
            {
             int result = Test.sum(678);
             System.out.println(result);



            }
}

要修复您自己的代码，只需将 return 添加到递归调用中即可。否则你总是 return 初始数字的所有数字的总和，你只想在只剩下一位数字时这样做。

static int sum(int s)
            {
                int n=s;
                 int add=0;
                 while(n%10 > 0)        
                 {
                     add = (n%10) +add;
                     n = n/10;
                     System.out.println("num is "  +n );
                 }

                if(add/10 > 0)
                {
                    System.out.println(add);
                    return sum(add);
                }
                return add;


            }

Answer 3

这涵盖了内部结果大于 10 的情况：

static int sum(int s) {

    if (s >= 10) {
        int t = s % 10 + sum(s / 10);
        if (t >= 10) {
            return sum(t);
        } else {
            return t;
        }

    } else {
        return s;
    }
}

以下紧凑函数产生相同的输出：

static int sum(int s) {

    if (s < 10) {
        return s;
    }

    return sum(s % 10 + sum(s / 10));
}

Answer 4

我发现了一个更简单的解决方案，使用关于数字和的数学关系

static int sum(int n) {
     return (n - 1) % 9 + 1;
}

PS：只需在您的控制台中尝试即可。

Answer 5

我是通过以下方式完成的：

public class DRoot {
  public static int digital_root(int n) {
  int sum=0;
  String s=String.valueOf(n);
  for(int i=0;i<s.length();i++){
    int a=Character.getNumericValue(s.charAt(i));    
    sum+=a;
  }

  if(sum > 9) {
      return digital_root(sum);    
  } else {
      return sum;
    }
  }

}

使用递归的数字总和/数字根

Sum of Digits / Digital Root using Recusrion

java

algorithm

recursion

core