Minimum Swaps to Sort by Digit Sum

Minimum Swaps to Sort by Digit Sum - Problem

You are given an array nums of distinct positive integers. You need to sort the array in increasing order based on the sum of the digits of each number.

If two numbers have the same digit sum, the smaller number appears first in the sorted order.

Return the minimum number of swaps required to rearrange nums into this sorted order. A swap is defined as exchanging the values at two distinct positions in the array.

Input & Output

Example 1 — Basic Case

$ Input: nums = [13, 12, 31, 21]

› Output: 3

💡 Note: Digit sums: 13→4, 12→3, 31→4, 21→3. Target order: [12, 21, 13, 31]. This requires one cycle of length 4, needing 3 swaps to resolve.

Example 2 — Already Sorted

$ Input: nums = [10, 11, 12]

› Output: 0

💡 Note: Digit sums: 10→1, 11→2, 12→3. Array is already sorted by digit sum, so 0 swaps needed.

Example 3 — Same Digit Sum

$ Input: nums = [21, 12]

› Output: 1

💡 Note: Both have digit sum 3, but 12 < 21, so target order is [12, 21]. Need 1 swap.

Constraints

1 ≤ nums.length ≤ 50
1 ≤ nums[i] ≤ 50

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 M Microsoft 15

The key insight is to find cycles in position mappings - each cycle of length k requires k-1 swaps. Best approach uses direct position mapping with cycle detection. Time: O(n log n), Space: O(n).

Common Approaches

✓ Brute Force Simulation

⏱️ Time: O(n log n) Space: O(n)

Calculate digit sums, create the target sorted array, then find cycles of misplaced elements. Each cycle of length k requires k-1 swaps to fix.

Direct Position Mapping

⏱️ Time: O(n log n) Space: O(n)

Instead of creating intermediate arrays, directly map each element to its target position using indices, then detect cycles more efficiently.

Brute Force Simulation — Algorithm Steps

Step 1: Calculate digit sum for each number
Step 2: Create target sorted array
Step 3: Find cycles of misplaced elements
Step 4: Count swaps as sum of (cycle_length - 1)

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate Digit Sums

Find digit sum for each number

Create Target Order

Sort by digit sum, then by value

Find Cycles

Detect cycles of misplaced elements

Count Swaps

Each cycle of length k needs k-1 swaps

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>

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

typedef struct {
    int digitSum;
    int value;
    int index;
} NumInfo;

int compare(const void *a, const void *b) {
    NumInfo *na = (NumInfo*)a;
    NumInfo *nb = (NumInfo*)b;
    if (na->digitSum != nb->digitSum) {
        return na->digitSum - nb->digitSum;
    }
    return na->value - nb->value;
}

int solution(int* nums, int n) {
    // Create array with digit sum info
    NumInfo* indexedNums = malloc(n * sizeof(NumInfo));
    for (int i = 0; i < n; i++) {
        indexedNums[i].digitSum = digitSum(nums[i]);
        indexedNums[i].value = nums[i];
        indexedNums[i].index = i;
    }
    
    // Sort by digit sum, then by value
    qsort(indexedNums, n, sizeof(NumInfo), compare);
    
    // Create mapping from original index to target index
    int* posMap = malloc(n * sizeof(int));
    for (int targetIdx = 0; targetIdx < n; targetIdx++) {
        int origIdx = indexedNums[targetIdx].index;
        posMap[origIdx] = targetIdx;
    }
    
    // Find cycles and count swaps
    bool* visited = calloc(n, sizeof(bool));
    int swaps = 0;
    
    for (int i = 0; i < n; i++) {
        if (visited[i] || posMap[i] == i) {
            continue;
        }
        
        // Count cycle length
        int cycleLength = 0;
        int curr = i;
        while (!visited[curr]) {
            visited[curr] = true;
            curr = posMap[curr];
            cycleLength++;
        }
        
        swaps += cycleLength - 1;
    }
    
    free(indexedNums);
    free(posMap);
    free(visited);
    return swaps;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse JSON array manually
    int nums[1000];
    int n = 0;
    char* token = strtok(line + 1, ",]"); // Skip '['
    while (token != NULL) {
        nums[n++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int result = solution(nums, n);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Sorting dominates with O(n log n), cycle detection is O(n)

⚡ Linearithmic

Space Complexity

O(n)

Extra arrays for target positions and visited tracking

⚡ Linearithmic Space

12.5K Views

Medium Frequency

~15 min Avg. Time

380 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler