Easy

题目描述

给定一个整数 n。

通过按原始顺序连接 n 的所有非零数字来形成一个新整数 x。如果没有非零数字，则 x = 0。

设 sum 为 x 中数字的和。

返回一个表示 x * sum 值的整数。

示例 1：

输入：n = 10203004
输出：12340
解释：
非零数字是 1、2、3 和 4。因此，x = 1234。
数字和是 sum = 1 + 2 + 3 + 4 = 10。
因此，答案是 x * sum = 1234 * 10 = 12340。

示例 2：

输入：n = 1000
输出：1
解释：
非零数字是 1，所以 x = 1，sum = 1。
因此，答案是 x * sum = 1 * 1 = 1。

约束条件：

  • 0 <= n <= 10^9

提示：

  • 按描述进行模拟

解题思路

这道题的核心思路是按照题目要求进行模拟：

  1. 提取非零数字：遍历输入数字 n 的每一位，提取所有非零数字并按原始顺序保存
  2. 构造新数字 x：将提取的非零数字按顺序连接形成新的整数 x
  3. 计算数字和：计算 x 中各位数字的和 sum
  4. 返回结果：返回 x * sum

具体实现可以有两种思路：

方法一（推荐）： 在提取非零数字的同时直接构造结果。我们可以一边提取非零数字构造 x，一边累加这些数字得到 sum。

方法二： 先将 n 转换为字符串，过滤掉零字符，然后重新构造数字。

这里推荐方法一，因为它只需要一次遍历，效率更高。对于边界情况，如果 n = 0 或者 n 的所有位都是 0，那么 x = 0，sum = 0，结果为 0。

时间复杂度为 O(log n)，其中 log n 是数字 n 的位数。空间复杂度为 O(1)。

代码实现

class Solution {
public:
    long long sumAndMultiply(int n) {
        if (n == 0) return 0;
        
        long long x = 0;
        int sum = 0;
        
        while (n > 0) {
            int digit = n % 10;
            if (digit != 0) {
                x = x * 10 + digit;
                sum += digit;
            }
            n /= 10;
        }
        
        // 需要反转x，因为我们是从低位到高位处理的
        long long reversed = 0;
        while (x > 0) {
            reversed = reversed * 10 + x % 10;
            x /= 10;
        }
        
        return reversed * sum;
    }
};

class Solution:
    def sumAndMultiply(self, n: int) -> int:
        if n == 0:
            return 0
        
        # 转换为字符串，过滤非零数字
        non_zero_digits = [d for d in str(n) if d != '0']
        
        if not non_zero_digits:
            return 0
        
        # 构造x
        x = int(''.join(non_zero_digits))
        
        # 计算数字和
        digit_sum = sum(int(d) for d in non_zero_digits)
        
        return x * digit_sum

public class Solution {
    public long SumAndMultiply(int n) {
        if (n == 0) return 0;
        
        string nStr = n.ToString();
        string nonZeroStr = "";
        int sum = 0;
        
        foreach (char c in nStr) {
            if (c != '0') {
                nonZeroStr += c;
                sum += c - '0';
            }
        }
        
        if (nonZeroStr == "") return 0;
        
        long x = long.Parse(nonZeroStr);
        return x * sum;
    }
}

/**
 * @param {number} n
 * @return {number}
 */
var sumAndMultiply = function(n) {
    let nonZeroDigits = n.toString().split('').filter(digit => digit !== '0');
    
    if (nonZeroDigits.length === 0) {
        return 0;
    }
    
    let x = parseInt(nonZeroDigits.join(''));
    let sum = nonZeroDigits.reduce((acc, digit) => acc + parseInt(digit), 0);
    
    return x * sum;
};
在 LeetCode 上运行： 力扣中文版 LeetCode 国际版

复杂度分析

复杂度类型值说明
时间复杂度O(log n)需要遍历数字n的每一位，位数为log n
空间复杂度O(log n)需要存储非零数字字符串，最多log n个字符