Count Symmetric Integers - Practice Coding Problems

Count Symmetric Integers - Problem

Math Enumeration Easy

Count Symmetric Integers

You are given two positive integers low and high. Your task is to count how many symmetric integers exist in the range [low, high] (inclusive).

A number is symmetric if:
• It has an even number of digits (numbers with odd digits are never symmetric)
• The sum of the first half of its digits equals the sum of the second half

For example, 1221 is symmetric because it has 4 digits, and 1+2 = 2+1. The number 123321 is also symmetric: 1+2+3 = 3+2+1 = 6.

Goal: Return the count of symmetric integers in the given range.

Input & Output

example_1.py — Basic Range

$ Input: low = 1, high = 100

› Output: 9

💡 Note: The symmetric integers in range [1,100] are: 11, 22, 33, 44, 55, 66, 77, 88, 99. Each has equal digit sums (1+1=2, 2+2=4, etc.)

example_2.py — Larger Range

$ Input: low = 1200, high = 1230

› Output: 4

💡 Note: The symmetric integers are: 1210 (1+2=2+1+0), 1221 (1+2=2+1), 1232 (1+2=3+2), but only 1221 works since 1+2=3 and 2+1=3. Actually: 1210, 1221, 1232 don't all work. Only 1221 is symmetric.

example_3.py — Small Range

$ Input: low = 1, high = 9

› Output: 0

💡 Note: All numbers from 1 to 9 have only 1 digit (odd), so none can be symmetric. Symmetric numbers must have even digit count.

Visualization

Tap to expand

Understanding the Visualization

Check Scale Type

Only even-digit numbers can be balanced (odd-digit numbers have no center point)

Split the Weights

Divide digits into left half and right half

Weigh Both Sides

Sum the digits on left side and right side

Check Balance

If sums are equal, the scale is perfectly balanced (symmetric)

Key Takeaway

🎯 Key Insight: Converting the problem to a balance scale analogy helps visualize that we need equal 'weight' (digit sums) on both halves of even-digit numbers.

Time & Space Complexity

Time Complexity

⏱️

O(n × d)

Where n is the range size (high - low) and d is average number of digits per number

✓ Linear Growth

Space Complexity

O(d)

Space for string representation of each number with d digits

✓ Linear Space

Constraints

1 ≤ low ≤ high ≤ 10⁴
Numbers with odd digit count are never symmetric
Both low and high are inclusive in the range

Asked in

G Google 15 a Amazon 12 ⊞ Microsoft 8 Apple 6

The optimal approach is a straightforward iteration through the range, checking each number for symmetry by comparing the sum of its first half digits with the second half. Since we must examine every number in the range, this gives us O(n × d) time complexity where n is the range size and d is the average number of digits.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check Every Number)	O(n × d)	O(d)	Iterate through every number in range and check if it's symmetric

Brute Force (Check Every Number) — Algorithm Steps

Iterate through each number from low to high
Convert number to string to access individual digits
Skip numbers with odd digit count
Calculate sum of first half and second half digits
Increment counter if sums are equal

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Range Iteration

Begin checking from 'low' to 'high'

Check Digit Count

Skip numbers with odd digit count

Split and Sum

Calculate sum of first half vs second half

Compare Sums

Increment counter if sums are equal

Code -

solution.c — C

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

int countSymmetricIntegers(int low, int high) {
    int count = 0;
    for (int num = low; num <= high; num++) {
        char s[20];
        sprintf(s, "%d", num);
        int n = strlen(s);
        
        // Skip odd-digit numbers
        if (n % 2 == 1) continue;
        
        // Calculate sum of first half and second half
        int mid = n / 2;
        int firstHalfSum = 0, secondHalfSum = 0;
        
        for (int i = 0; i < mid; i++) {
            firstHalfSum += s[i] - '0';
        }
        for (int i = mid; i < n; i++) {
            secondHalfSum += s[i] - '0';
        }
        
        if (firstHalfSum == secondHalfSum) {
            count++;
        }
    }
    return count;
}

int main() {
    int low, high;
    scanf("[%d, %d]", &low, &high);
    printf("%d\n", countSymmetricIntegers(low, high));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × d)

Where n is the range size (high - low) and d is average number of digits per number

✓ Linear Growth

Space Complexity

O(d)

Space for string representation of each number with d digits

✓ Linear Space

Constraints

1 ≤ low ≤ high ≤ 10⁴
Numbers with odd digit count are never symmetric
Both low and high are inclusive in the range

23.4K Views

Medium Frequency

~12 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

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Check Every Number) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler