1class Solution {
2    public long sumAndMultiply(int n) {
3        // placeValue tracks the positional multiplier (1, 10, 100, ...)
4        // for building the number with zero digits removed
5        int placeValue = 1;
6
7        // compactedNumber: n with all zero digits stripped out
8        // digitSum: the sum of all digits of n
9        int compactedNumber = 0, digitSum = 0;
10
11        // Process each digit from least significant to most significant
12        for (; n > 0; n /= 10) {
13            int digit = n % 10;
14
15            // Always add the digit to the total digit sum
16            digitSum += digit;
17
18            // Only keep non-zero digits when rebuilding the number
19            if (digit != 0) {
20                compactedNumber += placeValue * digit;
21                // Advance to the next place value only for kept digits
22                placeValue *= 10;
23            }
24        }
25
26        // Multiply the compacted number by the digit sum
27        // Use 1L to force long arithmetic and avoid integer overflow
28        return 1L * compactedNumber * digitSum;
29    }
30}
31

1class Solution {
2public:
3    long long sumAndMultiply(int n) {
4        // placeValue tracks the current place (1, 10, 100, ...) used when
5        // rebuilding the number from its non-zero digits.
6        int placeValue = 1;
7        // compactNumber: the number formed by dropping all zero digits.
8        // digitSum: the sum of all digits (zeros contribute 0 anyway).
9        int compactNumber = 0;
10        int digitSum = 0;
11
12        // Process n digit by digit, from least significant to most significant.
13        for (; n > 0; n /= 10) {
14            int digit = n % 10;   // Extract the current least-significant digit.
15            digitSum += digit;    // Add it to the running digit sum.
16
17            // Only non-zero digits are kept when rebuilding compactNumber.
18            if (digit != 0) {
19                compactNumber += placeValue * digit; // Place digit at current position.
20                placeValue *= 10;                    // Advance to the next place value.
21            }
22        }
23
24        // Return the product of the compacted number and the digit sum.
25        // Use 1LL to force 64-bit multiplication and avoid overflow.
26        return 1LL * compactNumber * digitSum;
27    }
28};
29

1/**
2 * Computes the product of:
3 *   1. The number formed by removing all zero digits from `n` (compactNumber).
4 *   2. The sum of all digits of `n` (digitSum).
5 *
6 * Example: n = 1020
7 *   - digitSum      = 1 + 0 + 2 + 0 = 3
8 *   - compactNumber = 12 (zeros stripped from 1020)
9 *   - result        = 12 * 3 = 36
10 *
11 * @param n - A non-negative integer to process.
12 * @returns The compacted number multiplied by the digit sum.
13 */
14function sumAndMultiply(n: number): number {
15    // Place value (1, 10, 100, ...) used to rebuild the number without zeros.
16    let placeValue = 1;
17    // The number reconstructed from `n` with all zero digits removed.
18    let compactNumber = 0;
19    // Running total of all digits in `n`.
20    let digitSum = 0;
21
22    // Process each digit from least significant to most significant.
23    while (n > 0) {
24        const digit = n % 10; // Extract the current lowest digit.
25        digitSum += digit;    // Always add the digit to the sum.
26
27        // Only non-zero digits contribute to the compacted number.
28        if (digit !== 0) {
29            compactNumber += placeValue * digit; // Append digit at current place.
30            placeValue *= 10;                    // Advance to the next place value.
31        }
32
33        n = Math.floor(n / 10); // Drop the processed digit.
34    }
35
36    // Final result: compacted number scaled by the sum of digits.
37    return compactNumber * digitSum;
38}
39