# 3153. Sum of Digit Differences of All Pairs

## Description

You are given an array nums consisting of positive integers where all integers have the same number of digits.

The digit difference between two integers is the count of different digits that are in the same position in the two integers.

Return the sum of the digit differences between all pairs of integers in nums.

Example 1:

Input: nums = [13,23,12]

Output: 4

Explanation:
We have the following:
- The digit difference between 13 and 23 is 1.
- The digit difference between 13 and 12 is 1.
- The digit difference between 23 and 12 is 2.
So the total sum of digit differences between all pairs of integers is 1 + 1 + 2 = 4.

Example 2:

Input: nums = [10,10,10,10]

Output: 0

Explanation:
All the integers in the array are the same. So the total sum of digit differences between all pairs of integers will be 0.

Constraints:

• 2 <= nums.length <= 105
• 1 <= nums[i] < 109
• All integers in nums have the same number of digits.

## Solutions

### Solution 1: Counting

First, we get the number of digits $m$ in the array. Then for each digit, we count the occurrence of each number at this digit in the array nums, denoted as cnt. Therefore, the sum of the digit differences of all number pairs at this digit is:

$\sum_{v \in \textit{cnt}} v \times (n - v)$

where $n$ is the length of the array. We add up the digit differences of all digits and divide by $2$ to get the answer.

The time complexity is $O(n \times m)$, and the space complexity is $O(C)$, where $n$ and $m$ are the length of the array and the number of digits in the numbers, respectively; and $C$ is a constant, in this problem $C = 10$.

• class Solution {
public long sumDigitDifferences(int[] nums) {
int n = nums.length;
int m = (int) Math.floor(Math.log10(nums[0])) + 1;
int[] cnt = new int[10];
long ans = 0;
for (int k = 0; k < m; ++k) {
Arrays.fill(cnt, 0);
for (int i = 0; i < n; ++i) {
++cnt[nums[i] % 10];
nums[i] /= 10;
}
for (int i = 0; i < 10; ++i) {
ans += 1L * cnt[i] * (n - cnt[i]);
}
}
return ans / 2;
}
}

• class Solution {
public:
long long sumDigitDifferences(vector<int>& nums) {
int n = nums.size();
int m = floor(log10(nums[0])) + 1;
int cnt[10];
long long ans = 0;
for (int k = 0; k < m; ++k) {
memset(cnt, 0, sizeof(cnt));
for (int i = 0; i < n; ++i) {
++cnt[nums[i] % 10];
nums[i] /= 10;
}
for (int i = 0; i < 10; ++i) {
ans += 1LL * (cnt[i] * (n - cnt[i]));
}
}
return ans / 2;
}
};

• class Solution:
def sumDigitDifferences(self, nums: List[int]) -> int:
n = len(nums)
m = int(log10(nums[0])) + 1
ans = 0
for _ in range(m):
cnt = Counter()
for i, x in enumerate(nums):
nums[i], y = divmod(x, 10)
cnt[y] += 1
ans += sum(v * (n - v) for v in cnt.values()) // 2
return ans


• func sumDigitDifferences(nums []int) (ans int64) {
n := len(nums)
m := int(math.Floor(math.Log10(float64(nums[0])))) + 1
for k := 0; k < m; k++ {
cnt := [10]int{}
for i, x := range nums {
cnt[x%10]++
nums[i] /= 10
}
for _, v := range cnt {
ans += int64(v) * int64(n-v)
}
}
ans /= 2
return
}

• function sumDigitDifferences(nums: number[]): number {
const n = nums.length;
const m = Math.floor(Math.log10(nums[0])) + 1;
let ans: bigint = BigInt(0);
for (let k = 0; k < m; ++k) {
const cnt: number[] = Array(10).fill(0);
for (let i = 0; i < n; ++i) {
++cnt[nums[i] % 10];
nums[i] = Math.floor(nums[i] / 10);
}
for (let i = 0; i < 10; ++i) {
ans += BigInt(cnt[i]) * BigInt(n - cnt[i]);
}
}
ans /= BigInt(2);
return Number(ans);
}