Count Number of Balanced Permutations - Practice Coding Problems

Count Number of Balanced Permutations - Problem

Imagine you're a mathematician arranging digits on a scale, where you need to balance the left side (even indices) against the right side (odd indices).

Given a string num containing only digits, your task is to count how many distinct permutations of this string are balanced. A permutation is considered balanced when:

Sum of digits at even indices (0, 2, 4, ...) equals
Sum of digits at odd indices (1, 3, 5, ...)

Example: For "123", the permutation "132" is balanced because position 0 has digit 1, position 1 has digit 3, position 2 has digit 2. So even sum = 1 + 2 = 3, odd sum = 3. They're equal!

Since the answer can be astronomically large, return it modulo 10⁹ + 7.

Input & Output

example_1.py — Basic Case

$ Input: num = "123"

› Output: 2

💡 Note: The balanced permutations are "132" (1+2=3, 3=3) and "231" (2+1=3, 3=3). Total sum is 6, so each side needs sum 3.

example_2.py — Single Digit

$ Input: num = "5"

› Output: 0

💡 Note: With only one digit, we have even sum = 5 and odd sum = 0. Since 5 ≠ 0, no balanced permutation exists.

example_3.py — All Zeros

$ Input: num = "0000"

› Output: 1

💡 Note: All permutations are identical "0000". Even sum = 0+0=0, odd sum = 0+0=0. Since 0=0, this single permutation is balanced.

Constraints

1 ≤ num.length ≤ 80
num consists of digits 0-9 only
Important: Answer must be returned modulo 10⁹ + 7

Visualization

Tap to expand

Understanding the Visualization

Identify the Scale

Even positions (0,2,4...) go on left pan, odd positions (1,3,5...) go on right pan

Count Available Weights

Tally how many of each digit (0-9) we have available to place

Calculate Target Weight

Total weight must be even, and each pan needs exactly half the total

Use Smart Counting

Instead of trying every arrangement, use math to count valid distributions

Key Takeaway

🎯 Key Insight: Transform the permutation counting problem into a dynamic programming problem by tracking digit distributions between even and odd positions, avoiding the exponential cost of generating all permutations.

Asked in

G Google 45 f Meta 32 a Amazon 28 ⊞ Microsoft 18

The optimal solution uses dynamic programming with combinatorics to count balanced permutations efficiently. Instead of generating all permutations (which would be O(n!)), we track digit frequencies and use DP to count valid arrangements where even and odd position sums are equal. Key insight: calculate combinations mathematically rather than enumerating permutations.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming with Combinatorics	O(n × sum)	O(n × sum)	Use DP to count valid arrangements without generating permutations
Generate All Permutations	O(n! × n)	O(n)	Generate every possible permutation and check if it's balanced

Dynamic Programming with Combinatorics — Algorithm Steps

Count frequency of each digit in the input
Calculate total sum and check if it's even (necessary for balance)
Determine target sum for even positions (total_sum / 2)
Use DP to count ways to select digits for even positions with target sum
Calculate combinations using factorial and digit frequencies
Return result modulo 10^9 + 7

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize State

Start with digit 0, 0 positions filled, sum 0

Try Distributions

For each digit, try all valid even/odd distributions

Calculate Combinations

Multiply by factorial for identical digit arrangements

Recurse to Next Digit

Move to next digit with updated state

Code -

solution.c — C

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

const int MOD = 1000000007;
long long fact[81];
long long memo[10][81][901]; // digit, evenUsed, evenSum
int memo_init[10][81][901];

void precompute_factorials(int n) {
    fact[0] = 1;
    for (int i = 1; i <= n; i++) {
        fact[i] = (fact[i-1] * i) % MOD;
    }
}

long long dp(int digit, int evenUsed, int evenSum, int* freq, int evenPos, int oddPos, int target, int n) {
    if (evenSum > target) return 0;
    
    if (memo_init[digit][evenUsed][evenSum]) {
        return memo[digit][evenUsed][evenSum];
    }
    
    if (digit == 10) {
        long long result = (evenUsed == evenPos && evenSum == target) ? 1 : 0;
        memo[digit][evenUsed][evenSum] = result;
        memo_init[digit][evenUsed][evenSum] = 1;
        return result;
    }
    
    if (freq[digit] == 0) {
        long long result = dp(digit + 1, evenUsed, evenSum, freq, evenPos, oddPos, target, n);
        memo[digit][evenUsed][evenSum] = result;
        memo_init[digit][evenUsed][evenSum] = 1;
        return result;
    }
    
    long long result = 0;
    int maxEven = freq[digit] < (evenPos - evenUsed) ? freq[digit] : (evenPos - evenUsed);
    
    for (int evenCount = 0; evenCount <= maxEven; evenCount++) {
        int oddCount = freq[digit] - evenCount;
        if (oddCount >= 0 && oddCount <= oddPos - (n - evenPos - evenUsed + evenCount)) {
            if (evenSum + evenCount * digit <= target) {
                long long ways = 1;
                if (evenCount > 0) ways = (ways * fact[evenCount]) % MOD;
                if (oddCount > 0) ways = (ways * fact[oddCount]) % MOD;
                
                ways = (ways * dp(digit + 1, evenUsed + evenCount, evenSum + evenCount * digit, freq, evenPos, oddPos, target, n)) % MOD;
                result = (result + ways) % MOD;
            }
        }
    }
    
    memo[digit][evenUsed][evenSum] = result;
    memo_init[digit][evenUsed][evenSum] = 1;
    return result;
}

int countBalancedPermutations(char* num) {
    char velunexorai[81];
    strcpy(velunexorai, num);
    int n = strlen(velunexorai);
    
    precompute_factorials(n);
    memset(memo_init, 0, sizeof(memo_init));
    
    // Count digit frequencies
    int freq[10] = {0};
    int totalSum = 0;
    for (int i = 0; i < n; i++) {
        int digit = velunexorai[i] - '0';
        freq[digit]++;
        totalSum += digit;
    }
    
    if (totalSum % 2 == 1) return 0;
    
    int target = totalSum / 2;
    int evenPos = (n + 1) / 2;
    int oddPos = n / 2;
    
    return (int)dp(0, 0, 0, freq, evenPos, oddPos, target, n);
}

Time & Space Complexity

Time Complexity

⏱️

O(n × sum)

DP table size is n positions times possible sum values

✓ Linear Growth

Space Complexity

O(n × sum)

Space for DP table and digit frequency arrays

⚡ Linearithmic Space

62.0K Views

Medium Frequency

~35 min Avg. Time

1.5K 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

Dynamic Programming with Combinatorics — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler