Count Number of Distinct Integers After Reverse Operations

Count Number of Distinct Integers After Reverse Operations - Problem

You're given an array nums containing positive integers. Your task is to perform a fascinating transformation: take each integer in the array, reverse its digits, and add these reversed numbers to the end of the array.

For example, if you have [13, 25], you'll reverse 13 to get 31 and 25 to get 52, resulting in the extended array [13, 25, 31, 52].

The challenge? Count how many distinct integers exist in the final array. Some numbers might appear multiple times (like when a number equals its reverse, such as palindromes), but you only count unique values.

Goal: Return the total count of distinct integers in the final transformed array.

Input & Output

example_1.py — Basic Case

$ Input: nums = [1, 13, 10, 12, 31]

› Output: 6

💡 Note: After reversing: 1→1, 13→31, 10→1, 12→21, 31→13. Extended array: [1,13,10,12,31,1,31,1,21,13]. Distinct numbers: {1,10,12,13,21,31} = 6 total.

example_2.py — With Duplicates

$ Input: nums = [2, 2, 2]

› Output: 1

💡 Note: All numbers are 2, and reverse of 2 is also 2. Extended array: [2,2,2,2,2,2]. Only one distinct number: {2} = 1 total.

example_3.py — Edge Case

$ Input: nums = [100]

› Output: 2

💡 Note: 100 reverses to 1 (leading zeros dropped). Extended array: [100, 1]. Distinct numbers: {1, 100} = 2 total.

Visualization

Tap to expand

Understanding the Visualization

Place Original Cards

Start with cards showing [13, 25] on the magic table

Create Mirror Cards

Mirror creates reversed cards: 13→31, 25→52

Magic Deduplication

Table now shows {13, 25, 31, 52} - all unique

Count Result

Count the cards remaining: 4 distinct numbers

Key Takeaway

🎯 Key Insight: Hash sets provide automatic deduplication - just add both original and reversed numbers, then return the set size!

Time & Space Complexity

Time Complexity

⏱️

O(n * d)

Single pass through array (O(n)) with digit reversal for each number (O(d) where d is average digits)

✓ Linear Growth

Space Complexity

O(n)

Hash set stores at most 2n distinct numbers (worst case when no duplicates)

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁶
All integers in nums are positive
Leading zeros are dropped when reversing (e.g., 1200 → 21, not 0021)

Asked in

a Amazon 35 ⊞ Microsoft 28 G Google 22 f Meta 18

The optimal solution uses a hash set to automatically track distinct numbers. For each number in the input, we add both the original number and its digit-reversed version to the set. The hash set eliminates duplicates automatically, so we simply return its size. This gives us O(n) time complexity and clean, efficient code.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Create Array + Manual Count)	O(n² + n*d)	O(n)	Create the full extended array, then manually count distinct elements
One-Pass Hash Set (Optimal)	O(n * d)	O(n)	Use hash set to automatically track distinct numbers in single pass

Brute Force (Create Array + Manual Count) — Algorithm Steps

Create helper function to reverse digits of a number
Build extended array: add all original numbers, then add all reversed numbers
Count distinct elements by checking each element against all others
Return the count of unique elements

Visualization

Tap to expand

Step-by-Step Walkthrough

Original Array

Start with [13, 25]

Reverse Numbers

13 → 31, 25 → 52

Extended Array

Combine to get [13, 25, 31, 52]

Manual Count

Compare each element with all previous ones

Code -

solution.c — C

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

int reverseNumber(int n) {
    char str[20];
    sprintf(str, "%d", n);
    int len = strlen(str);
    for (int i = 0; i < len/2; i++) {
        char temp = str[i];
        str[i] = str[len-1-i];
        str[len-1-i] = temp;
    }
    return atoi(str);
}

int countDistinctIntegers(int* nums, int numsSize) {
    int* extended = (int*)malloc(2 * numsSize * sizeof(int));
    
    // Copy original numbers
    for (int i = 0; i < numsSize; i++) {
        extended[i] = nums[i];
    }
    
    // Add reversed numbers
    for (int i = 0; i < numsSize; i++) {
        extended[numsSize + i] = reverseNumber(nums[i]);
    }
    
    // Count distinct elements manually
    int distinctCount = 0;
    for (int i = 0; i < 2 * numsSize; i++) {
        int isUnique = 1;
        for (int j = 0; j < i; j++) {
            if (extended[i] == extended[j]) {
                isUnique = 0;
                break;
            }
        }
        if (isUnique) distinctCount++;
    }
    
    free(extended);
    return distinctCount;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² + n*d)

O(n*d) to reverse all numbers (d = avg digits), O(n²) to count distinct elements

⚠ Quadratic Growth

Space Complexity

O(n)

Extra array to store 2n elements (original + reversed)

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁶
All integers in nums are positive
Leading zeros are dropped when reversing (e.g., 1200 → 21, not 0021)

23.2K Views

Medium Frequency

~12 min Avg. Time

847 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 (Create Array + Manual Count) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler