Count Symmetric Integers

Count Symmetric Integers - Problem

Math Enumeration Easy

You are given two positive integers low and high. An integer x consisting of 2 * n digits is symmetric if the sum of the first n digits of x is equal to the sum of the last n digits of x.

Numbers with an odd number of digits are never symmetric.

Return the number of symmetric integers in the range [low, high].

Input & Output

Example 1 — Small Range

$ Input: low = 1, high = 100

› Output: 9

💡 Note: Symmetric numbers: 11 (1=1), 22 (2=2), 33 (3=3), 44 (4=4), 55 (5=5), 66 (6=6), 77 (7=7), 88 (8=8), 99 (9=9). All single digits and odd-length numbers are not symmetric.

Example 2 — Four Digit Range

$ Input: low = 1200, high = 1230

› Output: 1

💡 Note: Only 1221 is symmetric in this range: left sum = 1+2 = 3, right sum = 2+1 = 3. Numbers like 1234 have left sum = 1+2 = 3, right sum = 3+4 = 7.

Example 3 — No Symmetric Numbers

$ Input: low = 1, high = 10

› Output: 0

💡 Note: No symmetric numbers exist. Single digit numbers (1-9) have odd length, and 10 has left sum = 1, right sum = 0.

Constraints

1 ≤ low ≤ high ≤ 10⁹
Numbers with odd digits are never symmetric
Only even-length numbers can be symmetric

Visualization

Tap to expand

Asked in

G Google 25 M Microsoft 20 a Amazon 15

The key insight is that only numbers with even digit count can be symmetric, where left half digit sum equals right half digit sum. Brute force checks every number in range O(n×d). Mathematical approach organizes by digit length for better range filtering. Time: O(n×d), Space: O(1)

Common Approaches

✓ Two Pointers

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

Brute Force Check Every Number

⏱️ Time: O(n × d) Space: O(1)

For each number in the range, convert to string, check if even length, split in half, and compare digit sums of left and right halves.

Mathematical Enumeration

⏱️ Time: O(10^k × k) Space: O(1)

Instead of checking every number, generate symmetric numbers by constructing them with equal left and right digit sums for each possible length.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int power(int base, int exp) {
    int result = 1;
    for (int i = 0; i < exp; i++) {
        result *= base;
    }
    return result;
}

int solution(int low, int high) {
    int count = 0;
    // Check all possible even digit lengths
    for (int digits = 2; digits <= 8; digits += 2) {  // 2, 4, 6, 8 digits
        int minNum = power(10, digits - 1);
        int maxNum = power(10, digits) - 1;
        
        // Skip if this digit length is outside our range
        if (minNum > high || maxNum < low) {
            continue;
        }
            
        // For this digit length, check all numbers
        int start = (low > minNum) ? low : minNum;
        int end = (high < maxNum) ? high : maxNum;
        
        for (int num = start; num <= end; num++) {
            char s[20];
            sprintf(s, "%d", num);
            int len = strlen(s);
            
            if (len == digits) {
                int mid = digits / 2;
                int leftSum = 0;
                int rightSum = 0;
                
                for (int i = 0; i < mid; i++) {
                    leftSum += s[i] - '0';
                }
                for (int i = mid; i < digits; i++) {
                    rightSum += s[i] - '0';
                }
                
                if (leftSum == rightSum) {
                    count++;
                }
            }
        }
    }
    
    return count;
}

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

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

18.5K Views

Medium Frequency

~15 min Avg. Time

890 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