Difference Between Element Sum and Digit Sum of an Array

Difference Between Element Sum and Digit Sum of an Array - Problem

Array Math Easy

You're given a positive integer array nums, and your task is to calculate two different types of sums and find their absolute difference.

Element Sum: Simply add up all the numbers in the array as they are.
Digit Sum: Break down each number into its individual digits, then add up all these digits.

For example, if you have the array [123, 45]:
• Element sum = 123 + 45 = 168
• Digit sum = (1+2+3) + (4+5) = 6 + 9 = 15
• Absolute difference = |168 - 15| = 153

Return the absolute difference between these two sums. The absolute difference ensures we always get a positive result, regardless of which sum is larger.

Input & Output

example_1.py — Basic Case

$ Input: [1,15,6,3]

› Output: 9

💡 Note: Element sum = 1+15+6+3 = 25, Digit sum = 1+(1+5)+6+3 = 16, Difference = |25-16| = 9

example_2.py — Larger Numbers

$ Input: [1,2,3,4]

› Output: 0

💡 Note: Element sum = 1+2+3+4 = 10, Digit sum = 1+2+3+4 = 10, Difference = |10-10| = 0

example_3.py — Multi-digit Numbers

$ Input: [123,456]

› Output: 564

💡 Note: Element sum = 123+456 = 579, Digit sum = (1+2+3)+(4+5+6) = 21, Difference = |579-21| = 558

Constraints

1 ≤ nums.length ≤ 2000
1 ≤ nums[i] ≤ 2000
All numbers are positive integers

Visualization

Tap to expand

Understanding the Visualization

Setup Two Counters

Initialize element_sum and digit_sum to 0

Process Each Item

For each number, add it to element_sum

Extract Digits

Use num % 10 to get last digit, num / 10 to remove it

Add to Digit Sum

Add each extracted digit to digit_sum

Calculate Difference

Return |element_sum - digit_sum|

Key Takeaway

🎯 Key Insight: We can efficiently solve this in one pass by maintaining two running totals - one for the numbers themselves, another for their individual digits extracted using modulo arithmetic.

Asked in

G Google 12 a Amazon 8 ⊞ Microsoft 6 f Meta 4

The optimal solution uses a single pass through the array, simultaneously calculating both the element sum and digit sum. Use mathematical operations (modulo and division) instead of string conversion for efficient digit extraction. Time complexity is O(n × d) where d is the average number of digits.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (String Conversion)	O(n * d)	O(d)	Convert each number to string to extract digits, calculate both sums separately
Single Pass Mathematical (Optimal)	O(n * d)	O(1)	Calculate both sums in one pass using mathematical operations to extract digits

Brute Force (String Conversion) — Algorithm Steps

Initialize element_sum and digit_sum to 0
For each number in the array, add it to element_sum
Convert each number to string and iterate through each character
Convert each character back to integer and add to digit_sum
Return absolute difference between the two sums

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate Element Sum

Add all numbers directly: 123 + 45 = 168

Convert to Strings

123 → '123', 45 → '45'

Extract Digits

'123' → [1,2,3], '45' → [4,5]

Sum Digits

1+2+3+4+5 = 15

Calculate Difference

|168 - 15| = 153

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int differenceOfSum(int* nums, int numsSize) {
    int elementSum = 0;
    int digitSum = 0;
    
    for (int i = 0; i < numsSize; i++) {
        elementSum += nums[i];
        int num = nums[i];
        while (num > 0) {
            digitSum += num % 10;
            num /= 10;
        }
    }
    
    return abs(elementSum - digitSum);
}

int main() {
    int nums[1000];
    int size = 0;
    char input[10000];
    fgets(input, sizeof(input), stdin);
    
    char* token = strtok(input, "[,]");
    while (token != NULL && size < 1000) {
        int num = atoi(token);
        if (num > 0) {
            nums[size++] = num;
        }
        token = strtok(NULL, "[,]");
    }
    
    printf("%d\n", differenceOfSum(nums, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * d)

Where n is array length and d is average number of digits per number

✓ Linear Growth

Space Complexity

O(d)

Space for string conversion of each number

✓ Linear Space

23.4K Views

Medium Frequency

~8 min Avg. Time

845 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (String Conversion) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler