Max Sum of a Pair With Equal Sum of Digits

Max Sum of a Pair With Equal Sum of Digits - Problem

Imagine you're a data analyst looking for special number pairs in a dataset. You have an array of positive integers, and you need to find two different numbers that share a unique property: they have the same digit sum.

For example, the numbers 23 and 41 both have a digit sum of 5 (2+3=5, 4+1=5), making them a valid pair.

Your Goal: Find the pair with the maximum sum among all valid pairs. If no such pair exists, return -1.

Key Concepts:

Digit Sum: Sum of all digits in a number (e.g., 123 → 1+2+3 = 6)
Valid Pair: Two different array elements with equal digit sums
Objective: Maximize the sum of the pair values themselves

Input & Output

example_1.py — Basic Case

$ Input: [18, 43, 36, 13, 7]

› Output: 54

💡 Note: The pairs with equal digit sums are: (18,36) with digit sum 9, and (43,13) with digit sum 7. The maximum pair sum is 18+36=54.

example_2.py — Multiple Valid Pairs

$ Input: [10, 12, 19, 14]

› Output: -1

💡 Note: No two numbers have the same digit sum: 10→1, 12→3, 19→10, 14→5. Therefore, no valid pairs exist.

example_3.py — Large Numbers

$ Input: [229, 398, 269, 317, 420, 464, 491, 218, 439]

› Output: 953

💡 Note: Several pairs have equal digit sums. The pair (464, 491) both have digit sum 14 and give the maximum sum: 464+491=955. Wait, let me recalculate: 229(13), 398(20), 269(17), 317(11), 420(6), 464(14), 491(14), 218(11), 439(16). The pairs are (464,491) with sum 955, and (317,218) with sum 535. Maximum is 955.

Visualization

Tap to expand

Understanding the Visualization

Meet a New Suspect

Calculate their clue value (digit sum) and check your notebook

Check for Match

If you've seen this clue before, you found a pair! Calculate the potential reward

Update Notebook

Remember the most valuable suspect for this clue type

Track Best Reward

Keep track of the highest reward found across all pairs

Key Takeaway

🎯 Key Insight: By storing only the maximum value for each digit sum, we can find valid pairs in one pass while immediately calculating the best possible reward, achieving optimal O(n) time complexity!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array with O(log(max_value)) digit sum calculation per element

✓ Linear Growth

Space Complexity

O(k)

Hash map stores at most k unique digit sums, where k ≤ min(n, max_digit_sum)

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹
The array contains positive integers only
Maximum digit sum is 9×10 = 90 for a 10-digit number

Asked in

a Amazon 45 G Google 38 f Meta 32 ⊞ Microsoft 28 Apple 22

The optimal solution uses a one-pass hash table approach with O(n) time complexity. For each number, we calculate its digit sum and check if we've seen this digit sum before. If yes, we have a valid pair and update our maximum. We then update the hash table with the maximum value for this digit sum. This elegant approach avoids the O(n²) brute force solution and the unnecessary sorting overhead of other methods.

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers (Sorted Groups)	O(n log n)	O(n)	Group by digit sum, sort each group, use two pointers to find maximum pair
Brute Force (Nested Loops)	O(n²)	O(1)	Check every pair of numbers to find the maximum sum with equal digit sums
One-Pass Hash Table (Optimal)	O(n)	O(k)	Build hash map and find maximum pair sum simultaneously in one pass

Two Pointers (Sorted Groups) — Algorithm Steps

Create a helper function to calculate digit sum
Group all numbers by their digit sums using a hash map
For each digit sum group with 2+ elements:
Sort the group in descending order
The maximum pair is the sum of the first two elements
Track the global maximum across all groups

Visualization

Tap to expand

Step-by-Step Walkthrough

Group by Digit Sum

Organize numbers into groups based on their digit sums

Sort Each Group

Sort numbers within each group in descending order

Find Maximum Pair

The first two elements in each group give the maximum pair

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#define MAX_DIGIT_SUM 100
#define MAX_NUMS 1000

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

int compare(const void* a, const void* b) {
    return (*(int*)b - *(int*)a); // Descending order
}

int maximumSum(int* nums, int numsSize) {
    // Group numbers by digit sum
    int groups[MAX_DIGIT_SUM][MAX_NUMS];
    int groupSizes[MAX_DIGIT_SUM] = {0};
    
    for (int i = 0; i < numsSize; i++) {
        int ds = digitSum(nums[i]);
        groups[ds][groupSizes[ds]++] = nums[i];
    }
    
    int maxSum = -1;
    
    // For each group with 2+ elements, find max pair
    for (int ds = 0; ds < MAX_DIGIT_SUM; ds++) {
        if (groupSizes[ds] >= 2) {
            // Sort in descending order
            qsort(groups[ds], groupSizes[ds], sizeof(int), compare);
            // Maximum pair is first two elements
            int pairSum = groups[ds][0] + groups[ds][1];
            if (pairSum > maxSum) {
                maxSum = pairSum;
            }
        }
    }
    
    return maxSum;
}

int main() {
    int nums[1000];
    int size = 0;
    char c;
    int num = 0;
    int reading = 0;
    
    while ((c = getchar()) != '\n' && c != EOF) {
        if (c >= '0' && c <= '9') {
            num = num * 10 + (c - '0');
            reading = 1;
        } else if (reading) {
            nums[size++] = num;
            num = 0;
            reading = 0;
        }
    }
    if (reading) nums[size++] = num;
    
    printf("%d\n", maximumSum(nums, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Grouping takes O(n), sorting all groups takes O(n log n) in worst case

⚡ Linearithmic

Space Complexity

O(n)

Hash map stores all numbers grouped by digit sum

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹
The array contains positive integers only
Maximum digit sum is 9×10 = 90 for a 10-digit number

42.3K Views

Medium-High Frequency

~15 min Avg. Time

1.8K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Two Pointers (Sorted Groups) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler