Question

方法返回应该如果输入一个数字，假设345，那么输出应该是3 + 4 + 5 = 12 - ＆gt; 1 + 2 = 3。我在这里做错了什么？

public class DigitSum
 {
    int  Sum=0;

    public int compute( int MethParam )
    {
        int rem = MethParam%10; 
        Sum+=rem;        

        MethParam = MethParam/10; 
        if(MethParam>10)
            compute(MethParam);

        return Sum+MethParam;  
    }

  public static void main(String[] args)
  {
    DigitSum ds  = new DigitSum();
    System.out.println(ds.compute(435));
  }
}

Answer 1

O（1）Algo for the Number Of digits：

取任何数字的模数9将返回该数字的数字之和，直到获得一位数字。

如果数字是9的倍数，则总和将为9

一个班轮：

public int sumDigit(int n){
    return (n%9 == 0 && n != 0) ? 9 : n%9;
}

替代实施：

public int sumDigit(int n){

      int sum = n % 9;
      if(sum == 0){
          if(n > 0)
               return 9;
      }
      return sum;
}

Answer 2

您要找的是digital root。所以这是一个更好的解决方案，使用我链接的wiki页面中的公式。

没有递归： -

public static int compute( int n ) {
    return n - 9 * ((n - 1) / 9);
}

而且，如果你想要（我不认为你会这样），这里是单行 （使用递归）： -

public static int compute( int n ) {
    return n < 10 ? n : compute(n % 10 + compute(n / 10));
}

Answer 3

    public int FindSumDigit(int number)
    {
        if (number < 10) return number;
        int sum = 0;
        while (number > 0)
        {
            sum += number % 10;
            number = number / 10;
        }
        return FindSumDigit(sum);
    }

找到我的代码...... Poon你没有添加全部数字..在中间你自己继续添加最正确的数字。

Answer 4

这里有许多错误的答案。这是OP想要的：

方法返回应该如果输入一个数字，假设为345，那么输出应为3 + 4 + 5 = 12 - > 1 + 2 = 3。

这将完成这项工作：

public static int compute(int param) {
    int sum = 0;
    do {
        sum = 0;
        while (param > 0) {
            sum += param % 10;
            param /= 10;
        }
        param = sum;
    } while (sum >= 10);
    return sum;
}

Answer 5

我将您的方法更改为此，然后它提供了请求的结果：

public int compute(int methParam) {
    int sum = 0;
    for (int i = 0; methParam > 10; i++) {
        int currentDigit = methParam % 10;
        methParam = methParam / 10;
        sum = sum + currentDigit;
    }
    if (sum + methParam > 10) {
        return compute(sum + methParam);
    } else {
        return sum + methParam;
    }
}

请注意，我在方法中移动了sum的声明，而不是将其作为字段。

Answer 6

在您的代码中，您没有正确返回值来调用递归方法。

        if ((MethParam >= 10)){
            return compute(MethParam);
        }else
            return Sum + MethParam;

Answer 7

public int compute( int param )
{
    int x = param % 10;
    int y = param / 10;

    if (y > 0)
        return x + compute(y);

    return x;
}

public int computeNonRec(int param) {
    int result = 0;
    while (param > 0) {
        result += param % 10;
        param /= 10;
    }
    return result;
}

Answer 8

尝试

 public int sumDigit(int n) {
        int sum = 0;
        while (n > 0) {
            sum += n % 10;
            number = n / 10;
        }
        return sum;
    }

Answer 9

这是一个字符串解决方案：

public int compute( int MethParam )
{
    int sum = 0; 
    string meth = MethParam.ToString();        

    for (char x in meth) {
        sum += int.Parse(x);
    }
    if (sum >= 10) {
        return compute(sum);
    }
    else {
        return sum;
    }
}

此代码在C＃而不是Java中，因此请将其视为伪代码。

Answer 10

只是一种不同的方法，由于涉及的转换可能效率不高：

private static int getUltimateSum(int input) {
    String inputStr = String.valueOf(input);
    int sum = 0;
    for (int i = 0; i < inputStr.length(); i++) {
        int digit = Integer.valueOf(String.valueOf(inputStr.charAt(i)));
        sum += digit;
    }
    if(sum > 9)
        return getUltimateSum(sum);
    else
        return sum;
}

Answer 11

试

public class DigitSum {
int  Sum=0;
public int compute( int MethParam )
{
    int rem = MethParam%10; 
    Sum+=rem;        

    MethParam = MethParam/10; 
    if(MethParam>10)
        compute(MethParam);
    else
        Sum+=MethParam;

        if(Sum>=10){
        int temp=Sum;
        Sum=0;
        compute(temp);
    }

         return Sum;  
}

public static void main(String[] args){
    DigitSum ds= new DigitSum();
        System.out.println(ds.compute(435));
    }
}

Answer 12

最短的代码是 -

int compute(int n){
    while(n > 9){
        n = n - 9;
    }
    return n;
}

其中n是您想要计算其某些数字的数字。

编辑：仅对小数字有效，比如3位数。

编辑：测试了几个答案：

public class Test {
    public static void main(String [] args){
        int i = 0x0fefefef;

        long st1 = System.nanoTime();
        int n1 = sumDigit(i);
        long t1 = System.nanoTime() - st1;

        long st2 = System.nanoTime();
        int n2 = FindSumDigit(i);
        long t2 = System.nanoTime() - st2;

        long st3 = System.nanoTime();
        int n3 = compute(i);
        long t3 = System.nanoTime() - st3;

        long st4 = System.nanoTime();
        int n4 = compute1(i);
        long t4 = System.nanoTime() - st4;

        System.out.println("Tested for: "+i);
        System.out.println(n1+": "+t1);
        System.out.println(n2+": "+t2);
        System.out.println(n3+": "+t3);
        System.out.println(n4+": "+t4);
    }

    public static int sumDigit(int n){
      int sum = n % 9;
      if(sum == 0){
          if(n > 0)
               return 9;
      }
      return sum;
    }

    public static int FindSumDigit(int n)
    {
        if (n < 10) return n;
        int sum = 0;
        while (n > 0)
        {
            sum += n % 10;
            n = n / 10;
        }
        return FindSumDigit(sum);
    }

    public static int compute( int n ) {
        return n - 9 * ((n - 1) / 9);
    }

    public static int compute1(int n){
        while(n > 9){
            n = n - 9;
        }
        return n;
    }
}

以上是上述测试的结果：

Tested for: 267382767
3: 2432
3: 1621
3: 810
3: 5354519

Answer 13

使用我在tymz之前创建的这个简单的java代码，这是为了添加正数和负数：

class SumDigit
{
public static void main(String args[])
{
int sum, i,a,d;
a = Integer.parseInt(args[0]);
sum = 0;
for(i=1;i< =10;i++)
{
d = a%10;
a = a/10;
sum=sum + d;
} 
System.out.println("Sum of Digit :"+sum);
}
}

给定正数的所有数字的总和

13 个答案: