2

大家好，我有一个快速的问题。所以我有一个任务，我必须创建一个程序来递归计算整数中所有数字的总和。IE 整数 123 (1+2+3) = 6。如何让它从第一个数字开始，一直到没有其他数字为止？这是我到目前为止所拥有的......

import java.util.*;

public class sum 
{    
    /**
     * @param args
     */
    public static void main(String[] args) 
    {           
        System.out.println(sumDigits(123))   
    }

    public static  int sumDigits(int n)
    {
        while (n.hasNext())
        {
            return n.charAt(n.length) + sumDigits(n.charAt((n.length - 1)))
        }
    }
}

现在我知道我正在使用 (hasNext 和 charAt 我不应该......) 但是 int 的等价物是什么？

4

6 回答 6

5

您将需要两个操作：

获取数字的最后一位：n % 10

得到一个没有最后一位数字的数字：n / 10

在循环中使用这两个操作将为您提供号码的所有数字。

于 2013-09-18T06:24:02.650 回答
4

简单的递归解决方案：从号码的末尾开始，每一步都得到号码的最后一位（即m），然后将号码除以 10，即next。如果在某个步骤你得到 0 作为结果n / 10- 那么它是递归的结束，你可以返回你的余数。否则，您再次使用 . 调用您的函数next。

public static  int sumDigits(int n)
{
    int m = n % 10, next = n / 10;
    if (next == 0) {
        return m;
    }
    return m + sumDigits(next);
}
于 2013-09-18T06:32:15.860 回答
1

您可以尝试使用递归：

public int sumDigits(int n) {
    int abs = Math.abs(n), lastdigit = 0, sum = 0;
    if(n != 0) {
        lastdigit = abs % 10;
        sum = lastdigit + sumDigits(abs / 10);
    }
    return sum;
}

这里有一些测试：

@Test
public void sumDigits() {
    Assert.assertEquals(3, sumDigits(12));
    Assert.assertEquals(6, sumDigits(123));
    Assert.assertEquals(10, sumDigits(1234));
    Assert.assertEquals(15, sumDigits(12345));
    Assert.assertEquals(21, sumDigits(123456));
    Assert.assertEquals(28, sumDigits(1234567));
    Assert.assertEquals(28, sumDigits(7654321));
    Assert.assertEquals(28, sumDigits(-7654321));
    Assert.assertEquals(44, sumDigits(2056239854));
    Assert.assertEquals(46, sumDigits(Integer.MAX_VALUE)); // 2147483647
}
于 2013-09-18T06:54:00.710 回答
0

第一种方式：

public static int sumDigits(int n) {                
            int validate = n % 10;
            int digit = n / 10;
            if (validate == 0) 
                return validate;
            return validate + sumDigits(digit);
        }

第二种方式：

public static int sumDigits(int n) {    
            String[] temp = Integer.toString(n).split("");
            int sum = 0;
            for (int i = 1; i < temp.length; i++)// i=1 to skip first first empty value
                sum += Integer.parseInt(temp[i]);    
            return sum;   
         }

测试：

System.out.println("" + sumDigits(123)); // For both cases same O/p

输出： 

6
于 2013-09-18T06:24:13.867 回答
0

如何递归解决问题

考虑基本情况：如果 num<10，那么我们只想返回那个数字

其他情况是什么？在这种情况下，只有另一种情况：我们有更多的数字，我们需要添加第一个数字，然后处理其余的

public int sumDigits(int n){
     return sumDigitsHelper(n,0);
}

public int sumDigitsHelper(int n, int sum){
     if(n<10)
          return sum+n;
     return sumDigitsHelper(n/10,sum+n%10);

}
于 2013-09-18T06:34:38.407 回答
0

抱歉，错过了递归的要求。

public static int sumDigits(int n) {
  int sum = sumDigits0(n, 0);
  if (sum < 10) {
    return sum;
  }
  return sumDigits(sum);
}

private static int sumDigits(int n, int sum) {
  if (n == 0) {
    return sum;
  }
  return sumDigits(n/10, sum + (n%10));
}
于 2013-09-18T06:38:32.630 回答