Minimum Element After Replacement With Digit Sum

Minimum Element After Replacement With Digit Sum - Problem

Array Math Easy

Problem Statement:
You are given an integer array nums. Your task is to transform each element in the array by replacing it with the sum of its digits, then return the minimum element from the transformed array.

What you need to do:
1. For each number in the array, calculate the sum of its individual digits
2. Replace the original number with this digit sum
3. Find and return the smallest number in the transformed array

Example: If you have [99, 123, 5], it becomes [18, 6, 5] (since 9+9=18, 1+2+3=6, 5=5), and the minimum is 5.

Input & Output

example_1.py — Basic Case

$ Input: nums = [10, 12, 13, 14]

› Output: 1

💡 Note: The digit sums are: [1+0, 1+2, 1+3, 1+4] = [1, 3, 4, 5]. The minimum is 1.

example_2.py — Larger Numbers

$ Input: nums = [1, 2, 3, 4]

› Output: 1

💡 Note: Since all numbers are single digits, their digit sums are themselves: [1, 2, 3, 4]. The minimum is 1.

example_3.py — All Same Digit Sum

$ Input: nums = [999, 99, 9]

› Output: 9

💡 Note: The digit sums are: [9+9+9, 9+9, 9] = [27, 18, 9]. The minimum is 9.

Visualization

Tap to expand

Understanding the Visualization

Start with Original Array

We have an array of integers that need to be transformed

Calculate Digit Sums

For each number, extract digits and sum them up

Track Minimum

Keep track of the smallest digit sum encountered so far

Return Result

The minimum digit sum is our answer

Key Takeaway

🎯 Key Insight: We can find the minimum digit sum in a single pass without storing all transformed values, making the solution both time and space efficient!

Time & Space Complexity

Time Complexity

⏱️

O(n * d)

Where n is array length and d is average number of digits per number

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for minimum tracking

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 100
1 ≤ nums[i] ≤ 10⁴
All elements are positive integers

Asked in

G Google 25 a Amazon 18 ⊞ Microsoft 15 f Meta 12

The optimal approach uses a single pass through the array, calculating each element's digit sum and tracking the running minimum. This achieves O(n×d) time complexity with O(1) space complexity, where d is the average number of digits per number.

Common Approaches

Approach	Time	Space	Notes
✓ Transform Array Then Find Minimum	O(n * d)	O(n)	Transform all elements first, then find the minimum in a second pass
Single Pass with Running Minimum (Optimal)	O(n * d)	O(1)	Calculate digit sums and track minimum in one pass through the array

Transform Array Then Find Minimum — Algorithm Steps

Create a new array to store digit sums
Iterate through original array and calculate digit sum for each element
Store each digit sum in the new array
Iterate through the transformed array to find the minimum value
Return the minimum

Visualization

Tap to expand

Step-by-Step Walkthrough

Transform Elements

Calculate digit sum for each element and store in new array

Find Minimum

Scan through transformed array to find the smallest value

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>

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

int minElement(int* nums, int numsSize) {
    // Transform all elements
    int* transformed = (int*)malloc(numsSize * sizeof(int));
    for (int i = 0; i < numsSize; i++) {
        transformed[i] = digitSum(nums[i]);
    }
    
    // Find minimum
    int min = transformed[0];
    for (int i = 1; i < numsSize; i++) {
        if (transformed[i] < min) {
            min = transformed[i];
        }
    }
    
    free(transformed);
    return min;
}

int main() {
    int nums[] = {10, 12, 13, 14};
    printf("%d\n", minElement(nums, 4));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * d)

Where n is array length and d is average number of digits per number

✓ Linear Growth

Space Complexity

O(n)

Need extra array to store all transformed values

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 100
1 ≤ nums[i] ≤ 10⁴
All elements are positive integers

28.0K Views

Medium Frequency

~10 min Avg. Time

850 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

Transform Array Then Find Minimum — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler