Minimum Swaps to Sort by Digit Sum - Practice Coding Problems

Minimum Swaps to Sort by Digit Sum - Problem

You're working with an array of distinct positive integers that needs to be sorted in a special way. Instead of sorting by the actual values, you need to sort by the sum of each number's digits!

Here's the twist: if two numbers have the same digit sum, the smaller number comes first. Your task is to find the minimum number of swaps needed to arrange the array in this special order.

Example: For [321, 45, 123]:
• 321 → digit sum = 3+2+1 = 6
• 45 → digit sum = 4+5 = 9
• 123 → digit sum = 1+2+3 = 6

Since 321 and 123 both have digit sum 6, but 123 < 321, the sorted order should be [123, 321, 45]. This requires 1 swap (swap 321 and 123).

Goal: Return the minimum number of adjacent or non-adjacent swaps to achieve this digit-sum-based sorted order.

Input & Output

example_1.py — Basic Case

$ Input: [321, 45, 123]

› Output: 1

💡 Note: Digit sums: 321→6, 45→9, 123→6. Target order: [123, 321, 45]. Need 1 swap to move 321 and 123.

example_2.py — Already Sorted

$ Input: [12, 34, 56]

› Output: 0

💡 Note: Digit sums: 12→3, 34→7, 56→11. Array is already sorted by digit sum, so 0 swaps needed.

example_3.py — Multiple Cycles

$ Input: [432, 21, 111, 6]

› Output: 2

💡 Note: Digit sums: 432→9, 21→3, 111→3, 6→6. Target: [21, 111, 6, 432]. Two swaps needed: positions form cycles that require 2 swaps total.

Constraints

1 ≤ nums.length ≤ 10³
1 ≤ nums[i] ≤ 10⁴
All integers in nums are distinct
Each number is a positive integer

Visualization

Tap to expand

Understanding the Visualization

Calculate Digit Sums

For each number, sum its digits to get the sorting key

Determine Target Order

Sort by digit sum, with smaller numbers breaking ties

Map Positions

Create mapping from current position to target position

Find Cycles

Detect cycles in position mapping - each cycle represents elements that need to rotate

Count Swaps

Each cycle of length k requires exactly k-1 swaps to resolve

Key Takeaway

🎯 Key Insight: This problem is fundamentally about cycle detection in permutations. By mapping current positions to target positions and counting cycle lengths, we can determine the minimum swaps mathematically rather than through simulation.

Asked in

G Google 42 a Amazon 38 ⊞ Microsoft 31 f Meta 24

The optimal approach uses cycle detection in permutations. After creating the target sorted array based on digit sums, we map current positions to target positions. Each cycle of length k requires exactly k-1 swaps to resolve, giving us O(n log n) time complexity and O(n) space.

Common Approaches

Approach	Time	Space	Notes
✓ Cycle Detection with Position Mapping	O(n log n)	O(n)	Map current positions to target positions, then count cycles to determine minimum swaps
Brute Force Simulation	O(n! × n)	O(n! × n)	Simulate all possible swaps until array is sorted by digit sum

Cycle Detection with Position Mapping — Algorithm Steps

Calculate digit sum for each number and create target sorted array
Create position mapping: current_position -> target_position
Find all cycles in the position mapping using visited array
For each cycle of length k, add k-1 to the total swap count
Return total minimum swaps needed

Visualization

Tap to expand

Step-by-Step Walkthrough

Create Target

Sort array by digit sum to determine target positions

Position Mapping

Map each current position to its target position

Find Cycles

Detect cycles in the position mapping

Count Swaps

Each cycle of length k requires k-1 swaps

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.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;
} Item;

int compare(const void* a, const void* b) {
    Item* itemA = (Item*)a;
    Item* itemB = (Item*)b;
    
    if (itemA->digitSum != itemB->digitSum) {
        return itemA->digitSum - itemB->digitSum;
    }
    return itemA->value - itemB->value;
}

int minimumSwaps(int* nums, int n) {
    if (n <= 1) return 0;
    
    // Step 1: Create items array for sorting
    Item* items = (Item*)malloc(n * sizeof(Item));
    for (int i = 0; i < n; i++) {
        items[i].digitSum = digitSum(nums[i]);
        items[i].value = nums[i];
        items[i].index = i;
    }
    
    qsort(items, n, sizeof(Item), compare);
    
    // Step 2: Create position mapping
    int* posMapping = (int*)malloc(n * sizeof(int));
    
    // Create value to target position mapping
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (nums[i] == items[j].value) {
                posMapping[i] = j;
                items[j].value = -1; // Mark as used
                break;
            }
        }
    }
    
    // Step 3: Find cycles and count swaps
    int* visited = (int*)calloc(n, sizeof(int));
    int totalSwaps = 0;
    
    for (int i = 0; i < n; i++) {
        if (visited[i] || posMapping[i] == i) {
            continue;
        }
        
        // Found start of a cycle
        int cycleLength = 0;
        int current = i;
        
        while (!visited[current]) {
            visited[current] = 1;
            current = posMapping[current];
            cycleLength++;
        }
        
        // Each cycle of length k needs k-1 swaps
        totalSwaps += cycleLength - 1;
    }
    
    free(items);
    free(posMapping);
    free(visited);
    
    return totalSwaps;
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    // Parse simple format like [1,2,3]
    int nums[100];
    int n = 0;
    
    char* ptr = input + 1;  // Skip '['
    while (*ptr && *ptr != ']') {
        nums[n++] = atoi(ptr);
        while (*ptr && *ptr != ',' && *ptr != ']') ptr++;
        if (*ptr == ',') ptr++;
    }
    
    printf("%d\n", minimumSwaps(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

O(n log n) for sorting to create target array, O(n) for cycle detection

⚡ Linearithmic

Space Complexity

O(n)

O(n) space for target array, position mapping, and visited tracking

⚡ Linearithmic Space

28.4K Views

Medium Frequency

~15 min Avg. Time

847 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

Cycle Detection with Position Mapping — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler