Count Number of Balanced Permutations

Count Number of Balanced Permutations - Problem

You are given a string num containing only digits. A string of digits is called balanced if the sum of the digits at even indices is equal to the sum of the digits at odd indices.

Return the number of distinct permutations of num that are balanced. Since the answer may be very large, return it modulo 10⁹ + 7.

A permutation is a rearrangement of all the characters of a string.

Input & Output

Example 1 — Basic Case

$ Input: num = "123"

› Output: 2

💡 Note: Total sum is 6, so target for even positions is 3. Valid permutations are "132" (even: 1+2=3, odd: 3) and "231" (even: 2+1=3, odd: 3).

Example 2 — Impossible Case

$ Input: num = "112"

› Output: 1

💡 Note: Total sum is 4, target is 2. Only "121" works: even positions 1+1=2, odd position 2.

Example 3 — Single Digit

$ Input: num = "1"

› Output: 0

💡 Note: Single digit "1" at position 0 (even). Even sum = 1, odd sum = 0. Since 1 ≠ 0, it's not balanced.

Constraints

1 ≤ num.length ≤ 80
num consists of digits only

Visualization

Tap to expand

Asked in

G Google 25 f Meta 20 a Amazon 15

The key insight is to use combinatorial mathematics to count valid digit distributions. Instead of generating all permutations, we determine how many ways digits can be arranged such that even position sum equals odd position sum. Best approach uses dynamic programming to count distributions. Time: O(n × sum), Space: O(sum)

Common Approaches

✓ Math

⏱️ Time: N/A Space: N/A

Combinatorial Mathematics

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

Calculate the result using combinatorial mathematics by determining valid digit distributions and applying multinomial coefficients to count permutations directly without generating them.

Dynamic Programming with Memoization

⏱️ Time: O(n × sum × 10) Space: O(n × sum)

Use dynamic programming with memoization to count the number of ways to distribute digits such that even and odd position sums are equal, then apply combinatorics to get the final count.

Generate All Permutations

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

Generate every possible permutation of the input string, then check each one to see if the sum of digits at even indices equals the sum at odd indices.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int countUpTo(int num) {
    if (num < 0) return 0;
    
    char numStr[20];
    sprintf(numStr, "%d", num);
    int n = strlen(numStr);
    int result = 0;
    
    // Count all numbers with fewer digits
    for (int i = 1; i < n; i++) {
        if (i == 1) {
            result += 9;
        } else {
            int count = 9;
            for (int j = 2; j <= i; j++) {
                count *= (11 - j);
            }
            result += count;
        }
    }
    
    // Count numbers with same digits but smaller
    bool used[10] = {false};
    bool valid = true;
    for (int i = 0; i < n; i++) {
        int digit = numStr[i] - '0';
        int start = i == 0 ? 1 : 0;
        int count = 0;
        
        for (int d = start; d < digit; d++) {
            if (!used[d]) {
                count++;
            }
        }
        
        int remaining = n - i - 1;
        int usedCount = 0;
        for (int j = 0; j < 10; j++) {
            if (used[j]) usedCount++;
        }
        int available = 10 - usedCount - 1;
        
        if (remaining == 0) {
            result += count;
        } else {
            int ways = 1;
            for (int j = 0; j < remaining; j++) {
                if (available - j > 0) {
                    ways *= (available - j);
                }
            }
            result += count * ways;
        }
        
        if (used[digit]) {
            valid = false;
            break;
        }
        used[digit] = true;
    }
    
    if (valid) {
        result += 1;
    }
    
    return result;
}

int solution(int a, int b) {
    return countUpTo(b) - countUpTo(a - 1);
}

int main() {
    int a, b;
    scanf("%d", &a);
    scanf("%d", &b);
    
    int result = solution(a, b);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

27.7K Views

Medium Frequency

~35 min Avg. Time

892 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