recursividad - sumar los digitos de un entero java

¿Cómo sumar dígitos de un entero en java?

Question

Me está costando encontrar la solución a este problema. Estoy tratando de desarrollar un programa en Java que tome un número, como 321, y encuentre la suma de dígitos, en este caso 3 + 2 + 1 = 6. Necesito todos los dígitos de cualquier número de tres dígitos para sumarlos. y almacene ese valor utilizando el símbolo de% restante. Esto me ha estado confundiendo y agradecería cualquier idea.

Answer 1

¡Las recursiones son siempre más rápidas que los bucles!

Más corto y mejor:

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

Answer 2

¿No deberías poder hacerlo de forma recursiva? Soy un poco nuevo en la programación, pero tracé esto y creo que funciona.

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

Answer 3

Además de las respuestas aquí, puedo explicar un poco. En realidad es un problema matemático.

321 es el total de 300 + 20 + 1.

Si divide 300 por 100, obtiene 3.

Si divide 20 por 10, obtiene 2.

Si divide 1 por 1, obtiene 1.

Al final de estas operaciones, puede resumirlas todas y obtener 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 4

Aquí hay un programa simple para la suma de dígitos del número 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

O simple, puede usar esto ... verifique el siguiente programa.

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 5

El mío es más simple que los demás, espero que puedas entender esto si eres un programador nuevo como yo.

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 6

El siguiente método hará la tarea:

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;
}

Puedes usarlo así:

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

Answer 7

En Java 8,

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

Convierte el número en una cadena y luego cada carácter se asigna a su valor de dígito restando el valor ascii de ''0'' (48) y se agrega a la suma final.

Answer 8

En Java 8, esto es posible en una sola línea de código de la siguiente manera:

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

Answer 9

Esto debería funcionar bien para cualquier número de dígitos y devolverá la suma de dígitos individuales

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 10

Puede llegar un poco tarde ... pero así es como puedes hacerlo recursivamente

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

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

Answer 11

Puede que sea demasiado tarde, pero veo que muchas soluciones publicadas aquí utilizan la complejidad de tiempo O (n ^ 2), esto está bien para entradas pequeñas, pero a medida que avanza con entradas grandes, es posible que desee reducir la complejidad del tiempo. Aquí hay algo en lo que trabajé para hacer lo mismo en la complejidad lineal del tiempo.

NOTA: La segunda solución publicada por Arunkumar es la complejidad constante del tiempo.

    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;
}   

Ignore mi convención de nomenclatura variable, sé que no es lo ideal. Permítanme explicar el código con una entrada de muestra, por ejemplo, "12345". La salida debe ser 6, en un solo recorrido.

Básicamente, lo que estoy haciendo es pasar de LSB a MSB y agregar dígitos de la suma encontrada en cada iteración.

Los valores se ven así

Inicialmente 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 )

La respuesta es 6, y evitamos un bucle adicional. Espero que ayude.

Answer 12

Puedes hacerlo usando Recursion

//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 13

Si amas el tiempo constante, prueba esto:

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);

La lógica es que si agrega cualquier número entre 9, la suma resultante del dígito dará como resultado el mismo número.

Ejemplo : 6 + 9 = 15 y luego 1 + 5 = 6 (nuevamente tienes 6).

En caso de punto decimal, elimínelo y agregue los dígitos resultantes.

El siguiente código hace el truco:

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

Answer 14

Si necesita una sola línea, supongo que esta es una solución muy buena:

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

Answer 15

Solución recursiva Java 8, si no desea utilizar ninguna secuencia.

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

Cómo utilizar

Long sum = sumDigit.apply(123L);

La solución anterior funcionará para todos los números positivos. Si desea la suma de dígitos independientemente de positivo o negativo, utilice la solución a continuación.

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

Answer 16

Suma todos los dígitos independientemente del tamaño del número.

private static int sumOfAll(int num) {
    int sum = 0;
    if(num > 10) {
        sum += num % 10;
        while((num = num / 10) >= 1) {
            sum += (num > 10) ? num%10 : num;
        }
    }
    return sum;
}

Answer 17

Una solución simple usando flujos:

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

Answer 18

Haga clic aquí para ver el programa completo.

Código de muestra:

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 19

sin mapeo -> la solución lambda más rápida

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

... o compatible con Unicode

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

Answer 20

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); 
}

Salida

6