Comment faire la somme des chiffres d'un entier en java?
J'ai de la difficulté à trouver la solution à ce problème. J'essaie de développer un programme en Java qui prend un nombre, tel que 321, et trouve la somme des chiffres, dans ce cas 3 + 2 + 1 = 6. Il me faut tous les chiffres d'un nombre à trois chiffres et stockez cette valeur à l’aide du symbole% reste. Cela m'a dérouté et j'apprécierais les idées de n'importe qui.
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);
}
Sortie
6
Les récursions sont toujours plus rapides que les boucles!
Le plus court et le meilleur:
public static long sumDigits(long i) {
return i == 0 ? 0 : i % 10 + sumDigits(i / 10);
}
Vous pouvez le faire en utilisant la récursivité
//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;
}
Si vous aimez le temps constant, essayez ceci:
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 logique est que si vous ajoutez un nombre par 9, l’ajout du chiffre résultant donnera le même nombre.
Exemple : 6 + 9 = 15 puis 1 + 5 = 6 (vous en avez encore 6).
En cas de point décimal, supprimez-le et ajoutez les chiffres résultants.
Le code ci-dessous fait le tour:
i % 9 == 0 ? 9 : i % 9
Cela devrait fonctionner correctement pour n’importe quel nombre de chiffres et il renverra la somme de chaque chiffre.
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
}
Somme tous les chiffres quelle que soit la taille du nombre.
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;
}
La méthode suivante fera la tâche:
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;
}
Vous pouvez l'utiliser comme ceci:
System.out.printf("Sum of digits = %d%n", sumOfDigits(321));
En Java 8, cela est possible dans une seule ligne de code:
int sum = Pattern.compile("")
.splitAsStream(factorialNumber.toString())
.mapToInt(Integer::valueOf)
.sum();
En Java 8,
public int sum(int number) {
return (number + "").chars()
.map(digit -> digit % 48)
.sum();
}
Convertit le nombre en chaîne puis chaque caractère est mappé à sa valeur numérique en soustrayant la valeur ascii de '0' (48) et ajoutée à la somme finale
ne devriez-vous pas être capable de faire récursivement quelque chose comme ça? Je suis un peu nouveau dans le domaine de la programmation, mais je l'ai tracé et je pense que cela fonctionne.
int sum(int n){
return n%10 + sum(n/10);
}
Cliquez ici pour voir le programme complet
Exemple de code:
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);
}
Peut-être un peu tard .. mais voici comment vous pouvez le faire de manière récursive
public int sumAllDigits(int number) {
int sum = number % 10;
if(number/10 < 10){
return sum + number/10;
}else{
return sum + sumAllDigits(number/10);
}
Une solution simple utilisant des flux:
int n = 321;
int sum = String.valueOf(n)
.chars()
.map(Character::getNumericValue)
.sum();
C'est peut-être trop tard, mais je constate que de nombreuses solutions présentées ici utilisent la complexité temporelle de O (n ^ 2). Cela convient pour de petites entrées, mais si vous avancez avec des entrées volumineuses, vous souhaiterez peut-être réduire la complexité temporelle. Voici quelque chose sur lequel j'ai travaillé pour faire la même chose dans la complexité temporelle linéaire.
NOTE: La deuxième solution publiée par Arunkumar est une complexité temporelle constante.
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;
}
Ignorez s'il vous plaît ma convention d'appellation de variable, je sais que ce n'est pas idéal. Laissez-moi vous expliquer le code avec exemple de saisie, par exemple. "12345". La sortie doit être 6, en une seule traversée.
Fondamentalement, je passe de LSB à MSB, et j'ajoute des chiffres de la somme trouvée, à chaque itération.
Les valeurs ressemblent à ceci
Initialement 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 réponse est 6, et nous avons évité une boucle supplémentaire ... J'espère que cela vous aidera.