Find Numbers with Even Number of Digits - Practice Coding Problems

Find Numbers with Even Number of Digits - Problem

Array Math Easy

You're a data analyst working with a dataset of integers, and you need to perform a specific analysis: count how many numbers have an even number of digits.

Given an array nums of integers, return the count of numbers that contain an even number of digits. For example, the number 1234 has 4 digits (even), while 123 has 3 digits (odd).

Key Points:

Single digit numbers (0-9) have 1 digit (odd)
Two digit numbers (10-99) have 2 digits (even)
Three digit numbers (100-999) have 3 digits (odd)
And so on...

Your task is to efficiently count all numbers in the array that have 2, 4, 6, 8, ... digits.

Input & Output

example_1.py — Basic Case

$ Input: [12,345,2,6,7896]

› Output: 2

💡 Note: Numbers 12 (2 digits) and 7896 (4 digits) have even number of digits. Numbers 345 (3 digits), 2 (1 digit), and 6 (1 digit) have odd number of digits.

example_2.py — Single Elements

$ Input: [555,901,482,1771]

› Output: 1

💡 Note: Only number 1771 has 4 digits (even). Numbers 555, 901, and 482 all have 3 digits (odd).

example_3.py — Edge Cases

$ Input: [0,10,100,1000]

› Output: 2

💡 Note: Numbers 10 (2 digits) and 1000 (4 digits) have even digits. Numbers 0 (1 digit) and 100 (3 digits) have odd digits.

Constraints

1 ≤ nums.length ≤ 500
1 ≤ nums[i] ≤ 10⁵
All integers are positive (no negative numbers in constraints)

Visualization

Tap to expand

Understanding the Visualization

Scan Number

The scanner reads each number from the array

Count Digits

Digital counter determines digit count (like counting barcode stripes)

Check Parity

System checks if count is even (green light) or odd (red light)

Update Result

Even numbers increment our final counter

Key Takeaway

🎯 Key Insight: The problem reduces to efficiently counting digits and using the modulo operator to check parity - either through string conversion for simplicity or mathematical division for efficiency.

Asked in

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

This problem can be solved efficiently using string conversion or mathematical digit counting. Both approaches iterate through the array once, count digits for each number, and check if the count is even using the modulo operator. The string conversion approach is more intuitive, while the mathematical approach avoids string overhead.

Common Approaches

Approach	Time	Space	Notes
✓ Mathematical Digit Counting	O(n * log k)	O(1)	Use mathematical operations to count digits without string conversion

Mathematical Digit Counting — Algorithm Steps

Iterate through each number in the array
Handle special case of 0 (has 1 digit)
Use absolute value to handle negative numbers
Count digits by repeatedly dividing by 10 OR use log10
Check if digit count is even using modulo 2

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with Number

Begin with the original number

Divide by 10

Keep dividing by 10 until number becomes 0

Count Divisions

Each division represents one digit

Check Parity

Determine if count is even or odd

Code -

solution.c — C

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

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

int findNumbers(int* nums, int numsSize) {
    int count = 0;
    for (int i = 0; i < numsSize; i++) {
        int digits = countDigits(nums[i]);
        if (digits % 2 == 0) {
            count++;
        }
    }
    return count;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    int nums[500];
    int size = 0;
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        nums[size++] = atoi(token);
        token = strtok(NULL, "[,]");
    }
    printf("%d\n", findNumbers(nums, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * log k)

Where n is array length and k is the maximum number value

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra space for counting

✓ Linear Space

89.5K Views

Medium Frequency

~8 min Avg. Time

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

Mathematical Digit Counting — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler