# Sudo Placement[1.7] | Greatest Digital Root

Given a number N, you need to find a divisor of N such that the Digital Root of that divisor is the greatest among all other divisors of N. If more than one divisors give the same greatest Digital Root then output the maximum divisor.

The Digital Root of a non-negative number can be obtained by repeatedly summing the digits of the number until we reach to a single digit. Example: DigitalRoot(98)=9+8=>17=>1+7=>8(single digit!). The task is to print the greatest divisor having the greatest Digital Root followed by a space and the Digital Root of that divisor.

Examples:

Input: N = 10
Output: 5 5
The divisors of 10 are: 1, 2, 5, 10. The Digital Roots of these divisors are as follows:
1=>1, 2=>2, 5=>5, 10=>1. The greatest Digital Root is 5 which is produced by divisor 5, so answer is 5 5

Input: N = 18
Output: 18 9
The divisors of 18 are: 1, 2, 3, 6, 9, 18. The Digital Roots of these divisors are as follows:
1=>1, 2=>2, 3=>3, 6=>6, 9=>9, 18=>9. As we can see that 9 and 18 both have the greatest Digital Root of 9. So we select the maximum of those divisors, that is Max(9, 18)=18. So answer is 18 9

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

A naive approach will be to iterate till N and find all the factors and their digit sums. Store the largest among them and print them.

Time Complexity: O(N)

An efficient approach is to loop till sqrt(N), then the factors will be i and n/i. Check for the largest digit sum among them, in case of similar digit sums, store the larger factor. Once the iteration is completed, print them.

Below is the implementation of the above approach.

## C++

 `// C++ program to print the ` `// digital roots of a number ` `#include ` `using` `namespace` `std; ` ` `  `// Function to return ` `// dig-sum ` `int` `summ(``int` `n) ` `{ ` `    ``if` `(n == 0) ` `        ``return` `0; ` `    ``return` `(n % 9 == 0) ? 9 : (n % 9); ` `} ` ` `  `// Function to print the Digital Roots ` `void` `printDigitalRoot(``int` `n) ` `{ ` ` `  `    ``// store the largest digital roots ` `    ``int` `maxi = 1; ` `    ``int` `dig = 1; ` ` `  `    ``// Iterate till sqrt(n) ` `    ``for` `(``int` `i = 1; i <= ``sqrt``(n); i++) { ` ` `  `        ``// if i is a factor ` `        ``if` `(n % i == 0) { ` `            ``// get the digit sum of both ` `            ``// factors i and n/i ` `            ``int` `d1 = summ(n / i); ` `            ``int` `d2 = summ(i); ` ` `  `            ``// if digit sum is greater ` `            ``// then previous maximum ` `            ``if` `(d1 > maxi) { ` `                ``dig = n / i; ` `                ``maxi = d1; ` `            ``} ` ` `  `            ``// if digit sum is greater ` `            ``// then previous maximum ` `            ``if` `(d2 > maxi) { ` `                ``dig = i; ` `                ``maxi = d2; ` `            ``} ` ` `  `            ``// if digit sum is same as ` `            ``// then previous maximum, then ` `            ``// check for larger divisor ` `            ``if` `(d1 == maxi) { ` `                ``if` `(dig < (n / i)) { ` `                    ``dig = n / i; ` `                    ``maxi = d1; ` `                ``} ` `            ``} ` ` `  `            ``// if digit sum is same as ` `            ``// then previous maximum, then ` `            ``// check for larger divisor ` `            ``if` `(d2 == maxi) { ` `                ``if` `(dig < i) { ` `                    ``dig = i; ` `                    ``maxi = d2; ` `                ``} ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``// Print the digital roots ` `    ``cout << dig << ``" "` `<< maxi << endl; ` `} ` ` `  `// Driver Code ` `int` `main() ` `{ ` `    ``int` `n = 10; ` ` `  `    ``// Function call to print digital roots ` `    ``printDigitalRoot(n); ` `    ``return` `0; ` `} `

## Java

 `// Java program to print the digital ` `// roots of a number ` `class` `GFG ` `{ ` `     `  `// Function to return dig-sum ` `static` `int` `summ(``int` `n) ` `{ ` `    ``if` `(n == ``0``) ` `        ``return` `0``; ` `    ``return` `(n % ``9` `== ``0``) ? ``9` `: (n % ``9``); ` `} ` ` `  `// Function to print the Digital Roots ` `static` `void` `printDigitalRoot(``int` `n) ` `{ ` ` `  `    ``// store the largest digital roots ` `    ``int` `maxi = ``1``; ` `    ``int` `dig = ``1``; ` ` `  `    ``// Iterate till sqrt(n) ` `    ``for` `(``int` `i = ``1``; i <= Math.sqrt(n); i++)  ` `    ``{ ` ` `  `        ``// if i is a factor ` `        ``if` `(n % i == ``0``)  ` `        ``{ ` `            ``// get the digit sum of both ` `            ``// factors i and n/i ` `            ``int` `d1 = summ(n / i); ` `            ``int` `d2 = summ(i); ` ` `  `            ``// if digit sum is greater ` `            ``// then previous maximum ` `            ``if` `(d1 > maxi)  ` `            ``{ ` `                ``dig = n / i; ` `                ``maxi = d1; ` `            ``} ` ` `  `            ``// if digit sum is greater ` `            ``// then previous maximum ` `            ``if` `(d2 > maxi)  ` `            ``{ ` `                ``dig = i; ` `                ``maxi = d2; ` `            ``} ` ` `  `            ``// if digit sum is same as ` `            ``// then previous maximum, then ` `            ``// check for larger divisor ` `            ``if` `(d1 == maxi) ` `            ``{ ` `                ``if` `(dig < (n / i)) ` `                ``{ ` `                    ``dig = n / i; ` `                    ``maxi = d1; ` `                ``} ` `            ``} ` ` `  `            ``// if digit sum is same as ` `            ``// then previous maximum, then ` `            ``// check for larger divisor ` `            ``if` `(d2 == maxi)  ` `            ``{ ` `                ``if` `(dig < i)  ` `                ``{ ` `                    ``dig = i; ` `                    ``maxi = d2; ` `                ``} ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``// Print the digital roots ` `    ``System.out.println(dig + ``" "` `+ maxi); ` `} ` ` `  `// Driver Code ` `public` `static` `void` `main(String[] args) ` `{ ` `    ``int` `n = ``10``; ` ` `  `    ``// Function call to print digital roots ` `    ``printDigitalRoot(n); ` `} ` `} ` `// This code is contributed by mits `

## C#

 `// C# program to print the digital ` `// roots of a number ` `using` `System; ` ` `  `class` `GFG ` `{ ` `     `  `// Function to return dig-sum ` `static` `int` `summ(``int` `n) ` `{ ` `    ``if` `(n == 0) ` `        ``return` `0; ` `    ``return` `(n % 9 == 0) ? 9 : (n % 9); ` `} ` ` `  `// Function to print the Digital Roots ` `static` `void` `printDigitalRoot(``int` `n) ` `{ ` ` `  `    ``// store the largest digital roots ` `    ``int` `maxi = 1; ` `    ``int` `dig = 1; ` ` `  `    ``// Iterate till sqrt(n) ` `    ``for` `(``int` `i = 1; i <= Math.Sqrt(n); i++)  ` `    ``{ ` ` `  `        ``// if i is a factor ` `        ``if` `(n % i == 0)  ` `        ``{ ` `            ``// get the digit sum of both ` `            ``// factors i and n/i ` `            ``int` `d1 = summ(n / i); ` `            ``int` `d2 = summ(i); ` ` `  `            ``// if digit sum is greater ` `            ``// then previous maximum ` `            ``if` `(d1 > maxi)  ` `            ``{ ` `                ``dig = n / i; ` `                ``maxi = d1; ` `            ``} ` ` `  `            ``// if digit sum is greater ` `            ``// then previous maximum ` `            ``if` `(d2 > maxi)  ` `            ``{ ` `                ``dig = i; ` `                ``maxi = d2; ` `            ``} ` ` `  `            ``// if digit sum is same as ` `            ``// then previous maximum, then ` `            ``// check for larger divisor ` `            ``if` `(d1 == maxi) ` `            ``{ ` `                ``if` `(dig < (n / i)) ` `                ``{ ` `                    ``dig = n / i; ` `                    ``maxi = d1; ` `                ``} ` `            ``} ` ` `  `            ``// if digit sum is same as ` `            ``// then previous maximum, then ` `            ``// check for larger divisor ` `            ``if` `(d2 == maxi)  ` `            ``{ ` `                ``if` `(dig < i)  ` `                ``{ ` `                    ``dig = i; ` `                    ``maxi = d2; ` `                ``} ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``// Print the digital roots ` `    ``Console.WriteLine(dig + ``" "` `+ maxi); ` `} ` ` `  `// Driver Code ` `public` `static` `void` `Main() ` `{ ` `    ``int` `n = 10; ` ` `  `    ``// Function call to print digital roots ` `    ``printDigitalRoot(n); ` `} ` `} ` ` `  `// This code is contributed ` `// by Akanksha Rai `

Output:

```5 5
```

Time Complexity: O(sqrt(N))

My Personal Notes arrow_drop_up

Striver(underscore)79 at Codechef and codeforces D

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Improved By : Mithun Kumar, Akanksha_Rai

Article Tags :
Practice Tags :

Be the First to upvote.

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.