Start learning free

LESSON 244 OF 671 · HELPER FUNCTIONS

Biggest Digit Sum in JavaScript with a Helper Method

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 109.
  • Return the number itself, not its digit sum.
STEP 1 OF 9
    Ctrl + Enter to check

    JAVASCRIPT · HELPER FUNCTIONS

    Biggest Digit Sum in JavaScript, explained

    Problem overview

    The method biggestDigitSum gets an array of whole numbers 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 have the same digit sum, the one that comes first wins. The method 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 the first, 19, wins the tie. For [0, 7] the sums are 0 and 7, so the answer is 7. The numbers are between 0 and 1,000,000,000, and none is negative.

    Approach: a helper for the digit sum

    The work is split in two methods. The helper digitSum turns one number into the sum of its digits. biggestDigitSum then walks through the array, keeping the best number so far and replacing it only when a number has a strictly bigger digit sum.

    To get the digits of a number, take the last one with n % 10 (the remainder after dividing by 10), add it to a total, and then drop it by dividing n by 10 and rounding down. Repeat until n is 0.

    Step by step

    1. In digitSum, start total at 0. If n is 0 the loop never runs, and 0 is the right answer.
    2. Loop while n > 0. Each turn removes one digit, so n reaches 0 once every digit is gone.
    3. Add the last digit: total += n % 10. For 472, 472 % 10 is 2.
    4. Drop the last digit: n = Math.floor(n / 10). In JavaScript, / keeps the fraction: 472 / 10 is 47.2. Math.floor rounds it down to 47.
    5. Return total after the loop.
    6. In biggestDigitSum, start best at nums[0]. Before any comparison, the first number is the best one seen.
    7. Loop over the numbers with for (let num of nums). The first pass compares the first number with itself, which changes nothing.
    8. Compare digit sums: if this.digitSum(num) is greater than this.digitSum(best), set best to num. Use >, not >=, so a tie keeps the earlier number.
    9. Return best, the number itself.

    The solution in JavaScript

    class Solution {
    digitSum(n) {
        let total = 0;
        while (n > 0) {
            total += n % 10;
            n = Math.floor(n / 10);
        }
        return total;
    }
    biggestDigitSum(nums) {
        let best = nums[0];
        for (let num of nums) {
            if (this.digitSum(num) > this.digitSum(best)) {
                best = num;
            }
        }
        return best;
    }
}

    Some details:

    • Division does not truncate. JavaScript has one number type, and / always divides exactly. Without Math.floor, n would go 472, 47.2, 4.72, 0.472 and keep shrinking through hundreds of turns, and each turn adds a fractional remainder: 47.2 % 10 is about 7.2. For 472 the "sum" ends up near 14.44 instead of 13.
    • Parameters can be changed. The helper assigns to n. That only changes its own copy of the number; the caller's array is untouched.
    • The helper is called twice per comparison. That is simple and fast enough for this lesson.

    Following 472

    With n = 472 and total = 0, the first turn adds 472 % 10, which is 2, so total becomes 2, and n becomes Math.floor(47.2), which is 47. The second turn adds 7, so total is 9, and n becomes 4. The third turn adds 4, so total is 13, and n becomes 0. The condition n > 0 is now false, and the helper returns 13. A number such as 1000 passes through the zeros: three turns add 0 each, and the last adds 1.

    In biggestDigitSum, the first example starts with best = 472 (sum 13). The number 472 is compared with itself and loses, 95 has sum 14 so it replaces best, and 1000 has sum 1 so it does not. The method returns 95.

    In the tie example [19, 55, 28], every digit sum is 10. Because the comparison is strict, 55 does not replace 19 (10 is not greater than 10), and neither does 28. The method returns 19, the first of the three. In [0, 7], the helper returns 0 for the number 0 without entering the loop, and 7 has the bigger sum, so 7 wins.

    Testing

    The helper on single numbers: digitSum(472) is 13, digitSum(95) is 14, digitSum(1000) is 1 and digitSum(0) is 0. On the statement's examples, the solution prints:

    95
19
7

    Common mistakes

    • Using >= in the comparison. On a tie the later number would replace the earlier one. For [19, 55, 28] that version returns 28, not 19.
    • Leaving out Math.floor. The number stays a fraction, and the digit sum is no longer a sum of whole digits.
    • Returning the digit sum. The method returns the number whose digits add up the most: 95, not 14.
    • Calling the helper without this. inside the class, which throws "digitSum is not defined".
    Keep going with JavaScript500+ step-by-step lessons, from your first line of code to coding interviews. Free to start.
    Start learning free