如何对 java 中的 integer 的数字求和？

Question

我很难找到解决这个问题的方法。 我正在尝试在 Java 中开发一个程序，它接受一个数字，例如 321，并计算数字的总和，在本例中为 3 + 2 + 1 = 6。我需要任何三位数的所有数字将它们相加，并使用 % 余数符号存储该值。 这一直让我感到困惑，我很感激任何人的想法。

Answer 1

public static void main(String[] args) {
        int num = 321;
        int sum = 0;
        while (num > 0) {
            sum = sum + num % 10;
            num = num / 10;
        }
        System.out.println(sum); 
}

输出

6

Answer 2

使用流的简单解决方案：

int n = 321;
int sum = String.valueOf(n)
    .chars()
    .map(Character::getNumericValue)
    .sum();

Answer 3

递归总是比循环快！

最短和最好：

public static long sumDigits(long i) {
    return i == 0 ? 0 : i % 10 + sumDigits(i / 10);
}

Answer 4

您可以使用递归来做到这一点

//Sum of digits till single digit is obtained
public int sumOfDigits(int num) 
        {
            int sum = 0;

            while (num > 0)
            {
                sum = sum + num % 10;
                num = num / 10;
            }

            sum = (sum <10) ? sum : sumOfDigits(sum);

            return sum;
        }

Answer 5

无需映射 ➜ 更快的 lambda 解决方案

Integer.toString( num ).chars().boxed().collect( Collectors.summingInt( (c) -> c - '0' ) );

...或与较慢的 % 运算符相同

Integer.toString( num ).chars().boxed().collect( Collectors.summingInt( (c) -> c % '0' ) );

...或 Unicode 兼容

Integer.toString( num ).codePoints().boxed().collect( Collectors.summingInt( Character::getNumericValue ) );

Answer 6

你不应该像这样递归地做吗？ 我对编程有点陌生，但我追踪到了这一点，我认为它有效。

int sum(int n){
return n%10 + sum(n/10);
}

Answer 7

如果你喜欢固定的时间，试试这个：

double d = 10984.491;

// converting to String because of floating point issue of precision
String s = new String(d + "").replaceAll("\\D+","");
int i = Integer.parseInt(s);      

System.out.println(i % 9 == 0 ? 9 : i % 9);

逻辑是，如果您将任何数字加 9，则结果相加的数字将产生相同的数字。

示例：6 + 9 = 15 然后 1 + 5 = 6（又是 6）。

在小数点的情况下，将其删除并添加结果数字。

下面的代码可以解决问题：

i % 9 == 0 ? 9 : i % 9

Answer 8

这应该适用于任意数量的数字，它会返回单个数字的总和

public static void main(String[] args) {
    Scanner input = new Scanner(System.in);
    System.out.println("enter a string");
    String numbers = input.nextLine();  //String would be 55
    int sum = 0;
    for (char c : numbers.toCharArray()) {
        sum += c - '0';
    }
    System.out.println(sum); //the answer is 10
}

Answer 9

不管数字的大小，对所有数字求和。

private static int sumOfAll(int num) {
    int sum = 0;

    if(num == 10) return 1;

    if(num > 10) {
        sum += num % 10;
        while((num = num / 10) >= 1) {
            sum += (num > 10) ? num%10 : num;
        }
    } else {
        sum += num;
    }
    return sum;
}

Answer 10

以下方法将完成任务：

public static int sumOfDigits(int n) {
    String digits = new Integer(n).toString();
    int sum = 0;
    for (char c: digits.toCharArray())
        sum += c - '0';
    return sum;
}

你可以这样使用它：

System.out.printf("Sum of digits = %d%n", sumOfDigits(321));

Answer 11

单击此处查看完整程序

示例代码：

public static void main(String args[]) {
    int number = 333;
    int sum = 0;
    int num = number;
    while (num > 0) {
        int lastDigit = num % 10;
        sum += lastDigit;
        num /= 10;
    }
    System.out.println("Sum of digits : "+sum);
}

Answer 12

在 Java 8 中，这可以在一行代码中实现，如下所示：

int sum = Pattern.compile("")
        .splitAsStream(factorialNumber.toString())
        .mapToInt(Integer::valueOf)
        .sum();

Answer 13

可能为时已晚，但我看到这里发布的许多解决方案使用 O(n^2) 时间复杂度，这对于小输入是可以的，但是当您继续处理大输入时，您可能希望降低时间复杂度。 这是我在线性时间复杂度上做同样的事情。

注意：Arunkumar 发布的第二个解决方案是恒定时间复杂度。

    private int getDigits(int num) {
    int sum =0;
    while(num > 0) { //num consists of 2 digits max, hence O(1) operation
        sum = sum + num % 10;
        num = num / 10;
    }   
    return sum;
}
public int addDigits(int N) {
    int temp1=0, temp2= 0;
    while(N > 0) {
        temp1= N % 10;
        temp2= temp1 + temp2;
        temp2= getDigits(temp2); // this is O(1) operation
        N = N/ 10;
    }
    return temp2;
}   

请忽略我的变量命名约定，我知道这并不理想。 让我用示例输入解释代码，例如“12345”。 在单次遍历中输出必须为 6。

基本上我所做的是从 LSB 到 MSB ，并在每次迭代中添加找到的总和的数字。

这些值看起来像这样

最初 temp1 = temp2 = 0

N     | temp1 ( N % 10)  | temp2 ( temp1 + temp2 )
12345 | 5                | 5   
1234  | 4                | 5 + 4 = 9 ( getDigits(9) = 9)
123   | 3                | 9 + 3 = 12 = 3 (getDigits(12) =3 )
12    | 2                | 3 + 2 = 5 (getDigits(5) = 5)
1     | 1                | 5 + 1 = 6 (getDigits(6) = 6 )

答案是 6，我们避免了一个额外的循环。 我希望它有帮助。

Answer 14

可能有点晚了..但这里是你如何递归地做到这一点

public int sumAllDigits(int number) {
    int sum = number % 10;

    if(number/10 < 10){
        return sum + number/10;
    }else{
        return sum + sumAllDigits(number/10);
}

Answer 15

在 Java 8 中，

public int sum(int number) {
  return (number + "").chars()
                      .map(digit -> digit % 48)
                      .sum();
}

将数字转换为字符串，然后通过减去 '0' (48) 的 ascii 值并将每个字符映射到它的数字值并添加到最终和。

Answer 16

如果您需要单线，我想这是一个非常好的解决方案：

int sum(int n){
  return n >= 10 ? n % 10 + sum(n / 10) : n;
}

Answer 17

Java 8 递归解决方案，如果您不想使用任何流。

UnaryOperator<Long> sumDigit = num -> num <= 0 ? 0 : num % 10 + this.sumDigit.apply(num/10);

如何使用

Long sum = sumDigit.apply(123L);

以上解决方案适用于所有正数。 如果您想要数字总和而不考虑正数或负数，请使用以下解决方案。

UnaryOperator<Long> sumDigit = num -> num <= 0 ? 
         (num == 0 ? 0 : this.sumDigit.apply(-1 * num)) 
         : num % 10 + this.sumDigit.apply(num/10);

Answer 18

Java 8 解决方案：

int n= 29;    
String.valueOf(n).chars().map(Character::getNumericValue).sum()

Answer 19

我们不应该仅仅尝试用递归来解决它，还应该寻找优化的解决方法。 一种这样的选择是使用尾递归。 递归算法的空间复杂度随着递归深度的增加而增加，可以使用尾递归进行优化

public class SumOfDigits {

    public int tailRecursiveSumOfDigits(int number, int accumulator)
    {

        if(number < 10)
            return accumulator + number;
        else{
            int remainder = number % 10;
            return tailRecursiveSumOfDigits(number/10, remainder + accumulator);
        }

    }
    public static void main(String[] args)
    {
        SumOfDigits sod = new SumOfDigits();
        System.out.println(sod.tailRecursiveSumOfDigits(1234,0));

    }
}

Answer 20

这是一个简单的程序，用于计算数字 321 的数字总和。

  import java.math.*;

        class SumOfDigits {
            public static void main(String args[]) throws Exception {
                int sum = 0;
                int i = 321;
                    sum = (i % 10) + (i / 10);
                        if (sum > 9) {
                            int n = (sum % 10) + (sum / 10);
                            System.out.print("Sum of digits of " + i + " is " + n);

                        }else{
                           System.out.print("Sum of digits of " + i + " is " + sum );     

    }

                }
        }


Output:

Sum of digits of 321 is 6

或者简单的你可以使用这个..检查下面的程序。

public class SumOfDigits {

public static void main(String[] args) 
{
    long num = 321;

/*  int rem,sum=0;
    while(num!=0)
    {
        rem = num%10;
        sum = sum+rem;
        num=num/10;
    }
    System.out.println(sum);

    */
    if(num!=0)
    {
        long sum = ((num%9==0) ? 9 : num%9);
        System.out.println(sum);
    }

}

Answer 21

我的比其他的更简单，希望你能理解这一点，如果你是一个像我这样的新程序员。

import java.util.Scanner;
import java.lang.Math;

public class DigitsSum {

    public static void main(String[] args) {

        Scanner in = new Scanner(System.in);
        int digit = 0;
        System.out.print("Please enter a positive integer: ");
        digit = in.nextInt();
        int D1 = 0;
        int D2 = 0;
        int D3 = 0;
        int G2 = 0;
        D1 = digit / 100;
        D2 = digit % 100;
        G2 = D2 / 10;
        D3 = digit % 10;


        System.out.println(D3 + G2 + D1);

    }
}

Answer 22

除了这里的答案，我可以解释一下。 这实际上是一个数学问题。

321 是 300 + 20 + 1 的总和。

如果将 300 除以 100，则得到 3。

如果将 20 除以 10，则得到 2。

如果将 1 除以 1，则得到 1。

在这些操作结束时，您可以将所有这些操作相加，得到 6。

public class SumOfDigits{

public static void main(String[] args) {
    int myVariable = 542;
    int checker = 1;
    int result = 0;
    int updater = 0;

    //This while finds the size of the myVariable
    while (myVariable % checker != myVariable) {
        checker = checker * 10;
    }

    //This for statement calculates, what you want.
    for (int i = checker / 10; i > 0; i = i / 10) {

        updater = myVariable / i;
        result += updater;
        myVariable = myVariable - (updater * i);
    }

    System.out.println("The result is " + result);
}
}

Answer 23

整数和= 1 +（输入-1）％9;