Concatenated Divisibility

Concatenated Divisibility - Problem

You are given an array of positive integers nums and a positive integer k.

A permutation of nums is said to form a divisible concatenation if, when you concatenate the decimal representations of the numbers in the order specified by the permutation, the resulting number is divisible by k.

Return the lexicographically smallest permutation (when considered as a list of integers) that forms a divisible concatenation. If no such permutation exists, return an empty list.

Input & Output

Example 1 — Basic Valid Case

$ Input: nums = [1,2,3], k = 6

› Output: [1,3,2]

💡 Note: Trying permutations: [1,2,3]→123 (123÷6=20.5, not divisible), [1,3,2]→132 (132÷6=22, divisible!), [2,1,3]→213 (not divisible), [2,3,1]→231 (not divisible), [3,1,2]→312 (312÷6=52, divisible!), [3,2,1]→321 (not divisible). Valid permutations are [1,3,2] and [3,1,2]. Lexicographically smallest is [1,3,2].

Example 2 — No Valid Solution

$ Input: nums = [1,2,5], k = 6

› Output: []

💡 Note: All possible concatenations: 125, 152, 215, 251, 512, 521. None are divisible by 6, so return empty array.

Example 3 — Single Element

$ Input: nums = [12], k = 4

› Output: [12]

💡 Note: Only one permutation possible: [12] → 12. Since 12 ÷ 4 = 3, it's divisible, so return [12].

Constraints

1 ≤ nums.length ≤ 12
1 ≤ nums[i] ≤ 10⁹
1 ≤ k ≤ 10³

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 a Amazon 8 f Meta 6

The key insight is to use dynamic programming with bitmasks to track which numbers are used and the current remainder modulo k, avoiding expensive string concatenation and integer overflow. Best approach uses DP with O(n × 2ⁿ × k) time and O(2ⁿ × k) space.

Common Approaches

✓ Brute Force - Try All Permutations

⏱️ Time: O(n! × n) Space: O(n)

Generate all possible permutations of the input array. For each permutation, concatenate the numbers into a single integer and check if it's divisible by k. Keep track of the lexicographically smallest valid permutation.

Dynamic Programming with Bitmask

⏱️ Time: O(n × 2ⁿ × k) Space: O(2ⁿ × k)

Use dynamic programming with bitmask to represent which numbers have been used. Track the current remainder when the concatenated number is divided by k. This avoids generating the full concatenated number and prevents overflow.

Brute Force - Try All Permutations — Algorithm Steps

Generate all permutations of nums
For each permutation, concatenate numbers into one integer
Check if concatenated number is divisible by k
Track lexicographically smallest valid permutation

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Permutations

Create all possible orderings of the input array

Test Each Permutation

Concatenate numbers and check divisibility by k

Track Best

Keep lexicographically smallest valid permutation

Code -

solution.c — C

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

static bool dp[1024][1000];
static int pow10[20];

int compareInts(const void* a, const void* b) {
    int ia = *(const int*)a;
    int ib = *(const int*)b;
    return (ia > ib) - (ia < ib);
}

int countDigits(int num) {
    int count = 0;
    if (num == 0) return 1;
    while (num > 0) {
        count++;
        num /= 10;
    }
    return count;
}

void solution(int* nums, int n, int k, int* result, int* resultSize) {
    // Initialize DP table
    memset(dp, false, sizeof(dp));
    dp[0][0] = true;
    
    // Precompute powers of 10 modulo k
    pow10[0] = 1;
    for (int i = 1; i < 20; i++) {
        pow10[i] = (pow10[i-1] * 10) % k;
    }
    
    // Fill DP table
    for (int mask = 0; mask < (1 << n); mask++) {
        for (int rem = 0; rem < k; rem++) {
            if (!dp[mask][rem]) continue;
            
            for (int i = 0; i < n; i++) {
                if (mask & (1 << i)) continue;
                
                int digits = countDigits(nums[i]);
                int newRem = (rem * pow10[digits] + nums[i]) % k;
                dp[mask | (1 << i)][newRem] = true;
            }
        }
    }
    
    // Check if solution exists
    if (!dp[(1 << n) - 1][0]) {
        *resultSize = 0;
        return;
    }
    
    // Reconstruct solution
    *resultSize = 0;
    int mask = 0;
    int rem = 0;
    
    for (int pos = 0; pos < n; pos++) {
        int candidates[10];
        int candidateCount = 0;
        
        for (int i = 0; i < n; i++) {
            if (!(mask & (1 << i))) {
                candidates[candidateCount++] = nums[i];
            }
        }
        qsort(candidates, candidateCount, sizeof(int), compareInts);
        
        for (int c = 0; c < candidateCount; c++) {
            int num = candidates[c];
            // Find original index
            int i = -1;
            for (int j = 0; j < n; j++) {
                if (nums[j] == num && !(mask & (1 << j))) {
                    i = j;
                    break;
                }
            }
            
            int digits = countDigits(num);
            int newRem = (rem * pow10[digits] + num) % k;
            int newMask = mask | (1 << i);
            
            bool canComplete = false;
            if (pos == n - 1) {
                canComplete = (newRem == 0);
            } else {
                canComplete = dp[newMask][newRem];
            }
            
            if (canComplete) {
                result[(*resultSize)++] = num;
                mask = newMask;
                rem = newRem;
                break;
            }
        }
    }
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    int nums[10];
    int size = 0;
    int k;
    
    char line[100];
    fgets(line, sizeof(line), stdin);
    
    // Parse array manually
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        if (token[0] >= '0' && token[0] <= '9') {
            nums[size++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    
    scanf("%d", &k);
    
    int result[10];
    int resultSize;
    solution(nums, size, k, result, &resultSize);
    
    printf("[");
    for (int i = 0; i < resultSize; i++) {
        printf("%d", result[i]);
        if (i < resultSize - 1) printf(",");
    }
    printf("]\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × n)

n! permutations, each taking O(n) time to concatenate and check

✓ Linear Growth

Space Complexity

O(n)

Space for storing current permutation and result

✓ Linear Space

8.2K Views

Medium Frequency

~35 min Avg. Time

245 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 - Try All Permutations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler