Start learning free

LESSON 248 OF 671 · HELPER FUNCTIONS

Biggest Digit Sum in Go: Compare with a Helper

Practice Read the full explanation

You get an array of integers nums. Return the number whose digits add up to the most.

The digit sum of 472 is 4 + 7 + 2 = 13. If two numbers have the same digit sum, return the one that comes first.

The work is split between two functions. The first one is a helper. It gets one number and returns the sum of its digits. The second one is the function that is graded. It uses the helper to compare the numbers.

Example 1:

Input: nums = [472, 95, 1000]
Output: 95
Explanation: The digit sums are 13, 14 and 1.
95 has the biggest one: 9 + 5 = 14.

Example 2:

Input: nums = [19, 55, 28]
Output: 19
Explanation: All three digit sums are 10.
19 comes first, so it wins the tie.

Example 3:

Input: nums = [0, 7]
Output: 7
Explanation: The digit sum of 0 is 0.
The digit sum of 7 is 7.

Constraints:

nums has at least one number.
Every number is between 0 and 10⁹.
Return the number itself, not its digit sum.

STEP 1 OF 9

Guided

Ctrl + Enter to check

GO · HELPER FUNCTIONS

Biggest Digit Sum in Go, explained

Problem overview

biggestDigitSum receives a slice of integers nums and returns the number whose digits add up to the most. The digit sum of 472 is 4 + 7 + 2 = 13. If two numbers tie, the one that comes first wins. The function returns the number itself, not its digit sum.

For [472, 95, 1000] the digit sums are 13, 14 and 1, so the answer is 95. For [19, 55, 28] all three sums are 10, so 19 wins by coming first. For [0, 7] the sums are 0 and 7, so the answer is 7.

Approach

A helper, digitSum, turns one number into its digit sum. Then biggestDigitSum works like finding a maximum: remember the best number so far and replace it whenever a number has a strictly bigger digit sum. Using a strict "greater than" is what makes a tie keep the earlier number.

Step by step

The helper digitSum(n):

Start total := 0. For n = 0 the loop never runs, so 0 is the right answer.
Go has no while, so write for n > 0, a loop with only a condition.
Add the last digit, n % 10, to total. For 472, 472 % 10 is 2.
Drop the last digit with n = n / 10. Integer division drops the remainder, so 472 becomes 47. Without this line the loop never ends.
Return total.

The function biggestDigitSum(nums):

Start best := nums[0]. The first number is the best one seen before any comparison.
Loop with for _, num := range nums. The first turn compares the first number with itself, which changes nothing.
If digitSum(num) > digitSum(best), set best = num.
Return best after the loop.

The solution in Go

func digitSum(n int) int {
    total := 0
    for n > 0 {
        total += n % 10
        n = n / 10
    }
    return total
}

func biggestDigitSum(nums []int) int {
    best := nums[0]
    for _, num := range nums {
        if digitSum(num) > digitSum(best) {
            best = num
        }
    }
    return best
}

Go passes arguments by value, so changing n inside digitSum does not touch the caller's number. That is why the helper can safely use its parameter as a working variable.

Tracing the helper

For 472, the loop runs three times. Printing n, the last digit and the total before each addition gives:

n = 472 last digit 2 total so far 0
n = 47 last digit 7 total so far 2
n = 4 last digit 4 total so far 9

After the third turn, total is 13 and n / 10 is 0, so the loop stops. For n = 0 the condition n > 0 is false from the start, the loop never runs, and the helper returns 0, which is the right digit sum for 0.

The helper assumes n is not negative, as the constraints promise (every number is between 0 and 1,000,000,000). A negative number would skip the loop and report 0.

Why compare through the helper

The main function never looks at digits itself. It asks digitSum for a number's sum and compares the sums. That keeps the "find the best" logic separate from the "add the digits" logic, and each part is easy to read alone.

The helper is called for best again on every turn, which repeats work. For the sizes in this lesson that is fine. If it mattered, you could keep the best digit sum in a second variable and update both together. The reference solution keeps one variable because it is the simpler picture.

Why the number is returned

The function returns best, which is always an element of nums. A common slip is to track the biggest digit sum and return that. For [472, 95, 1000] the biggest sum is 14, but the answer is 95, the number that has it.

The digit sums in the statement's examples can be checked directly: digitSum(95) is 14, digitSum(1000) is 1, and digitSum(19), digitSum(55) and digitSum(28) are all 10, which is the tie in the second example. The largest allowed number, 1,000,000,000, has a digit sum of 1, so it does not overflow or slow anything down: the loop runs once per digit, at most ten times.

Testing

[472 95 1000]  ->  95
[19 55 28]     ->  19
[0 7]          ->  7
digitSum(472)  ->  13
digitSum(0)    ->  0

Edge cases

A slice with one number returns that number, since the loop has nothing better to find. Zero is a valid number with a digit sum of 0, so a slice like [0, 0] returns the first 0. Numbers with trailing zeros, like 1000, add the zeros as 0 and gain nothing from them. Go's int is 64 bits, so the numbers allowed here fit comfortably and no overflow can occur. The helper also leaves the number you gave it untouched, because Go passes the argument by value.

Common mistakes

Using >=. On a tie the later number would replace the earlier one. For [19, 55, 28] the function would return 28.
Returning the digit sum. The function returns the number, so best holds a number from nums.
Forgetting n = n / 10. The loop would never end.
Starting best at 0. That works only if the numbers are non-negative; taking nums[0] is safe for any input.

Keep going with Go500+ step-by-step lessons, from your first line of code to coding interviews. Free to start.

Start learning free