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 are given a positive integer array nums.

The element sum is the sum of all the elements in nums.

The digit sum is the sum of all the digits (not necessarily distinct) that appear in nums.

Return the absolute difference between the element sum and digit sum of nums.

Note: The absolute difference between two integers x and y is defined as |x - y|.

Input & Output

Example 1 — Basic Case

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

› Output: 9

💡 Note: Element sum: 1 + 15 + 6 + 3 = 25. Digit sum: 1 + 1 + 5 + 6 + 3 = 16. Absolute difference: |25 - 16| = 9.

Example 2 — Single Digits

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

› Output: 0

💡 Note: Element sum: 1 + 2 + 3 + 4 = 10. Digit sum: 1 + 2 + 3 + 4 = 10. Absolute difference: |10 - 10| = 0.

Example 3 — Large Numbers

$ Input: nums = [99,88]

› Output: 153

💡 Note: Element sum: 99 + 88 = 187. Digit sum: 9 + 9 + 8 + 8 = 34. Absolute difference: |187 - 34| = 153.

Constraints

1 ≤ nums.length ≤ 2000
1 ≤ nums[i] ≤ 2000

Visualization

Tap to expand

Asked in

a Amazon 15 G Google 12

The key insight is to calculate both sums simultaneously in a single pass. For each number, add it to the element sum and extract its digits for the digit sum. Best approach is the single-pass solution with Time: O(n × d), Space: O(1).

Common Approaches

✓ Dfs

⏱️ Time: N/A Space: N/A

Single-Pass Approach

⏱️ Time: O(n × d) Space: O(1)

Iterate through the array once, calculating element sum and digit sum simultaneously. For each number, add it to element sum and extract its digits for digit sum.

Two-Pass Approach

⏱️ Time: O(n × d) Space: O(1)

First pass calculates the sum of all elements. Second pass extracts digits from each number and sums them. Finally return absolute difference.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int digitSum(int num) {
    int sum = 0;
    while (num > 0) {
        sum += num % 10;
        num /= 10;
    }
    return sum;
}

void dfs(int* nums, int size, int index, int* elementSum, int* digitSumTotal) {
    if (index >= size) {
        return;
    }
    
    *elementSum += nums[index];
    *digitSumTotal += digitSum(nums[index]);
    
    dfs(nums, size, index + 1, elementSum, digitSumTotal);
}

int solution(int* nums, int size) {
    if (size == 0) {
        return 0;
    }
    
    int elementSum = 0;
    int digitSumTotal = 0;
    
    dfs(nums, size, 0, &elementSum, &digitSumTotal);
    
    int diff = elementSum - digitSumTotal;
    return diff < 0 ? -diff : diff;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Remove newline
    line[strcspn(line, "\n")] = 0;
    
    // Parse array manually
    int nums[2000];
    int count = 0;
    
    char* ptr = line;
    while (*ptr) {
        if (isdigit(*ptr)) {
            long val = strtol(ptr, &ptr, 10);
            nums[count++] = (int)val;
        } else {
            ptr++;
        }
    }
    
    int result = solution(nums, count);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

34.2K Views

Medium Frequency

~8 min Avg. Time

856 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