Digital Root berechnen, gibt es einen besseren Weg?

Question

So berechnete ich die digitale Wurzel einer ganzen Zahl.

---

import acm.program.*; 

public class Problem7 extends ConsoleProgram 
{ 
    public void run() 
    { 
     println("This program calculates the digital root of an interger."); 

     int num = readInt("Enter the number: "); 
     int sum = 0; 
     while (true) 
     { 
      if (num > 0) 
      { 
       int dsum = num % 10; 
       num /= 10; 
       sum += dsum; 
      } 
      else if (sum > 9) 
      { 
       int dsum = sum % 10; 
       sum /= 10; 
       sum += dsum; 

      } else if (sum <= 9) break; 
     } 
     println("Digital Root is: " + sum); 
    } 

---

Das Programm funktioniert gut.

Gibt es einen besseren/kürzeren Weg zur Berechnung der digitalen Wurzel einer Zahl. ?

---

EDIT/ADDED: Hier wird die Implementierung des obigen Problems ist die Verwendung von Tyler ‚s Antwort, es funktioniert auch:

---

import acm.program.*; 

public class Problem7 extends ConsoleProgram 
{ 
    public void run() 
    { 
     println("This program calculates the digital root of an interger."); 

     int num = readInt("Enter the number: "); 
     println("Digital Root of " + num + " is: " + (1 + (num - 1) % 9)); 
    } 
} 

---

Answer 1

#include <stdio.h> 

int main(void) 
{ 
    int number; 
    scanf("%d", &number); 

    printf("The digital root of %d is %d.", number, (1 + (number - 1) % 9)); 
} 

Wäre ich nicht in der Lage gewesen Ramaner Formel zu finden, das ist, wie ich dieses Programm ... schreiben würde:

#include <stdio.h> 
#include <ctype.h> 

int main(void) 
{ 
    int c; 
    int number = 0; 
    while ((c = getchar()) != EOF) 
    { 
     if (isdigit(c)) 
      number += (c - '0'); 
    } 
    if (number <= 9) 
    { 
     printf("The digital root is %d\n", number); 
    } 
    else 
    { 
     printf("%d", number); 
    } 

} 

Nach dem Kompilieren zu Führen Sie das aus, im Grunde ketten Sie diese einfach zusammen. Ich glaube, vier ist das Meiste, das Sie für eine ganze Zahl benötigen könnten.

$ echo 829382938 | ./digitalroot | ./digitalroot | ./digitalroot | ./digitalroot 

Answer 2

ich den Eingang nehmen würde in als String stattdessen. Auf diese Weise können Sie den String einfach durchlaufen und mit Integer.parseInt() jede Zahl erfassen und hinzufügen. Sie können diese Nummer erneut in einen String konvertieren und den Code durchlaufen, um Ihren digitalen Root zu erhalten.

public void run() 
{ 
    println("This program calculates the digital root of an interger."); 

    String num = readLine("Enter the number: "); 
    int sum = 10; 
    while (num > 9) { 
     for (int x = 0; x < num.length(); x++) { 
     sum = Integer.parseInt(num.charAt(x)); 
     } 
     num = Integer.toString(sum); 
    } 
    println("Digital Root is: " + sum); 
} 

Answer 3

Ich persönlich nicht Ihre Schleife gefallen, die im wesentlichen zwei Schleifen ist (zunächst über die ursprünglichen Ziffern gehen, dann über die Ziffern der Summe gehen) püriert in einem. Wie wärs mit einer Prise von Rekursion:

private int sumDigits(int in){ 
    if (i>10) 
     return in%10 + sumDigits(in/10); 
    return in; 
} 

private int digitalRoot(int in){ 
    assert (in > 0) ; 
    while (in > 9) in=sumDigits(in); 
    return in; 
} 

Answer 4

Ich glaube, ich an der gleichen Stelle in der Klasse bin, keine Rekursion oder irgendwelche mäßig fortgeschrittenen Ideen (ich ein Super-Anfänger bin). Ich benutzte

public void run() { 
    println("This program finds the digital root of an integer."); 
    int n = readInt("Enter a positive integer: "); 
    int dsum = 0; 
     while (n>0) { 
      dsum += n % 10; 
      n /= 10; 
      if ((n==0) && (dsum>9)) { 
       n = dsum; 
       dsum = 0; 
      } 
     } 
    println("The digital root of the integer is " + dsum); 
} 

Answer 5

public static void main(String[] args) 


{ 
int n; 
Scanner scan=new Scanner(System.in); 
System.out.println("Enter the no. of which you want to find the digital root"); 
n=scan.nextInt(); 
System.out.println(n%9); 
} 

Answer 6

Wolfram Alpha ist erstaunlich. Es ziemlich Löffel fütterte mich die Folge Lösung:

int getDigitalRoot(int n, int base){ 
     return (1+(n-1)%base); } 

int getDigitalRoot(int n){ 
     return (1+(n-1)%9); } 

Dies ist eine O (1) Lösung, keine Schleifen oder Rekursion erforderlich.

Answer 7

Hier ist die kürzeste Lösung, die ich gefunden habe, die für alle Anwendungsfälle funktioniert.

public int digRoot(int num) { 
     num = 1015; { 
     return (1+(num-1)%9); 
     } 
} 

ref: https://dgeekspot.wordpress.com/2015/11/17/digital-root-algorithm/