Question

2535. 数组元素和与数字和的绝对差

English Version

题目描述

给你一个正整数数组 nums 。

• 元素和 是 nums 中的所有元素相加求和。
• 数字和 是 nums 中每一个元素的每一数位（重复数位需多次求和）相加求和。

返回 元素和 与 数字和 的绝对差。

注意：两个整数 x 和 y 的绝对差定义为 |x - y| 。

 

示例 1：

输入：nums = [1,15,6,3]
输出：9
解释：
nums 的元素和是 1 + 15 + 6 + 3 = 25 。
nums 的数字和是 1 + 1 + 5 + 6 + 3 = 16 。
元素和与数字和的绝对差是 |25 - 16| = 9 。

示例 2：

输入：nums = [1,2,3,4]
输出：0
解释：
nums 的元素和是 1 + 2 + 3 + 4 = 10 。
nums 的数字和是 1 + 2 + 3 + 4 = 10 。
元素和与数字和的绝对差是 |10 - 10| = 0 。

 

提示：

• 1 <= nums.length <= 2000
• 1 <= nums[i] <= 2000

解法

方法一：模拟

我们遍历数组 $nums$，计算元素和 $a$ 与数字和 $b$，最后返回 $|a - b|$ 即可。

时间复杂度 $O(n)$，其中 $n$ 为数组 $nums$ 的长度。空间复杂度 $O(1)$。

class Solution:
  def differenceOfSum(self, nums: List[int]) -> int:
    a, b = sum(nums), 0
    for x in nums:
      while x:
        b += x % 10
        x //= 10
    return abs(a - b)

class Solution {
  public int differenceOfSum(int[] nums) {
    int a = 0, b = 0;
    for (int x : nums) {
      a += x;
      for (; x > 0; x /= 10) {
        b += x % 10;
      }
    }
    return Math.abs(a - b);
  }
}

class Solution {
public:
  int differenceOfSum(vector<int>& nums) {
    int a = 0, b = 0;
    for (int x : nums) {
      a += x;
      for (; x; x /= 10) {
        b += x % 10;
      }
    }
    return abs(a - b);
  }
};

func differenceOfSum(nums []int) int {
  a, b := 0, 0
  for _, x := range nums {
    a += x
    for ; x > 0; x /= 10 {
      b += x % 10
    }
  }
  return abs(a - b)
}

func abs(x int) int {
  if x < 0 {
    return -x
  }
  return x
}

function differenceOfSum(nums: number[]): number {
  return nums.reduce((r, v) => {
    r += v;
    while (v !== 0) {
      r -= v % 10;
      v = Math.floor(v / 10);
    }
    return r;
  }, 0);
}

impl Solution {
  pub fn difference_of_sum(nums: Vec<i32>) -> i32 {
    let mut ans = 0;
    for &num in nums.iter() {
      let mut num = num;
      ans += num;
      while num != 0 {
        ans -= num % 10;
        num /= 10;
      }
    }
    ans
  }
}

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

方法二

impl Solution {
  pub fn difference_of_sum(nums: Vec<i32>) -> i32 {
    let a: i32 = nums.iter().sum();
    let b: i32 = nums
      .iter()
      .map(|&n|
        n
          .to_string()
          .chars()
          .map(|c| c.to_digit(10).unwrap() as i32)
          .sum::<i32>()
      )
      .sum();
    (a - b).abs()
  }
}