Iterar a través de cada dígito en un número

Question

Estoy tratando de crear un programa que dirá si un número dado a él es un "Happy Number" o no. Encontrar un número feliz requiere que cada dígito en el número se cuadre, y el resultado del cuadrado de cada dígito se sume.

En Python, se puede usar algo como esto:

SQUARE[d] for d in str(n) 

pero no puedo encontrar la manera de recorrer cada dígito en un número en Java. Como puede ver, soy nuevo en esto y no puedo encontrar una respuesta en los documentos de Java.

Answer 1

Puede usar una operación de módulo 10 para obtener el número más a la derecha y luego dividir el número entre 10 para obtener el siguiente número.

long addSquaresOfDigits(int number) { 
    long result = 0; 
    int tmp = 0; 
    while(number > 0) { 
     tmp = number % 10; 
     result += tmp * tmp; 
     number /= 10; 
    } 
    return result; 
} 

También puede ponerlo en una cadena y convertir eso en una matriz de caracteres e iterar a través de él haciendo algo como Math.pow(charArray[i] - '0', 2.0);

Answer 2

Suponiendo que el número es un entero, para empezar:

int num = 56; 
String strNum = "" + num; 
int strLength = strNum.length(); 
int sum = 0; 

for (int i = 0; i < strLength; ++i) { 
    int digit = Integer.parseInt(strNum.charAt(i)); 
    sum += (digit * digit); 
} 

Answer 3

Me pregunto qué método sería más rápido para dividir un número positivo en sus dígitos en Java, String vs módulo

public static ArrayList<Integer> splitViaString(long number) { 

    ArrayList<Integer> result = new ArrayList<>(); 
    String s = Long.toString(number); 

    for (int i = 0; i < s.length(); i++) { 
     result.add(s.charAt(i) - '0'); 
    } 
    return result; // MSD at start of list 
    } 

vs

public static ArrayList<Integer> splitViaModulo(long number) { 

    ArrayList<Integer> result = new ArrayList<>(); 

    while (number > 0) { 
     int digit = (int) (number % 10); 
     result.add(digit); 
     number /= 10; 
    } 
    return result; // LSD at start of list 
    } 

las pruebas de cada método por el que pasa Long.MAX_VALUE 10 millones de veces, la versión de cadena tomó 2.090 segundos y la versión de módulo 2.334 segundos. (Oracle Java 8 en Ubuntu de 64 bits que se ejecuta en Eclipse neón)

Así que no mucho en lo que realmente, pero yo estaba un poco sorprendido de que era más rápido Cadena