Count Nice Pairs in an Array - Practice Coding Problems

Count Nice Pairs in an Array - Problem

You are given an array nums consisting of non-negative integers. Your task is to find all "nice pairs" of indices in the array.

First, let's define what rev(x) means: it's the reverse of a non-negative integer x. For example:

rev(123) = 321
rev(120) = 21 (leading zeros are dropped)
rev(5) = 5

A pair of indices (i, j) is considered "nice" if it satisfies these conditions:

0 ≤ i < j < nums.length (valid indices with i before j)
nums[i] + rev(nums[j]) = nums[j] + rev(nums[i]) (the magic condition!)

Goal: Return the total number of nice pairs. Since this number can be very large, return it modulo 10⁹ + 7.

The key insight is that the condition can be rearranged as: nums[i] - rev(nums[i]) = nums[j] - rev(nums[j])

Input & Output

example_1.py — Basic Example

$ Input: nums = [42, 11, 1, 97]

› Output: 2

💡 Note: The nice pairs are (0,3) and (1,2). For (0,3): 42 + rev(97) = 42 + 79 = 121, and 97 + rev(42) = 97 + 24 = 121. For (1,2): 11 + rev(1) = 11 + 1 = 12, and 1 + rev(11) = 1 + 11 = 12.

example_2.py — All Same Differences

$ Input: nums = [13, 10, 35, 24, 76]

› Output: 4

💡 Note: All numbers have the same difference value: 13-31=-18, 10-01=9, 35-53=-18, 24-42=-18, 76-67=9. We have 3 numbers with diff=-18 giving C(3,2)=3 pairs, and 2 numbers with diff=9 giving C(2,2)=1 pair. Total: 4 pairs.

example_3.py — Edge Case

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

› Output: 0

💡 Note: No nice pairs exist. Differences are: 1-1=0, 2-2=0, 3-3=0. Wait, all have difference 0, so we have C(3,2)=3 pairs! Actually the answer should be 3, not 0.

Visualization

Tap to expand

Understanding the Visualization

Original Condition

nums[i] + rev(nums[j]) = nums[j] + rev(nums[i]) seems complex to check directly

Mathematical Rearrangement

Subtract rev(nums[j]) and nums[i] from both sides to get: rev(nums[i]) - nums[i] = rev(nums[j]) - nums[j]

Simplified Form

Or equivalently: nums[i] - rev(nums[i]) = nums[j] - rev(nums[j]). Now we just need to group by this difference!

Count Combinations

For each group of k numbers with same difference, there are k*(k-1)/2 pairs

Key Takeaway

🎯 Key Insight: By transforming the complex pair condition into a simple grouping problem, we reduce the time complexity from O(n²) to O(n) while making the solution more elegant and intuitive!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array, with O(log nums[i]) time to reverse each number

✓ Linear Growth

Space Complexity

O(n)

Hash map can store up to n different difference values in worst case

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁵
0 ≤ nums[i] ≤ 10⁹
Return the result modulo 10⁹ + 7

Asked in

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

The optimal solution uses a mathematical transformation and hash table. The key insight is rearranging the condition nums[i] + rev(nums[j]) = nums[j] + rev(nums[i]) to nums[i] - rev(nums[i]) = nums[j] - rev(nums[i]). This transforms the problem from checking pairs to grouping by identical difference values. We count frequencies of each difference and accumulate pairs as we process the array, achieving O(n) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Pairs)	O(n²)	O(1)	Check every possible pair (i,j) and verify if they satisfy the nice pair condition
One-Pass Hash Table (Optimal)	O(n)	O(n)	Transform the condition to nums[i] - rev(nums[i]) and count occurrences using hash map

Brute Force (Check All Pairs) — Algorithm Steps

Iterate through all pairs (i,j) where i < j
For each pair, calculate rev(nums[i]) and rev(nums[j])
Check if nums[i] + rev(nums[j]) = nums[j] + rev(nums[i])
If condition is met, increment the counter
Return the final count modulo 10^9 + 7

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with array [42, 11, 1, 97] and check all pairs

Check (0,1)

42 + rev(11) = 42 + 11 = 53, 11 + rev(42) = 11 + 24 = 35. Not equal.

Check (0,2)

42 + rev(1) = 42 + 1 = 43, 1 + rev(42) = 1 + 24 = 25. Not equal.

Check (1,3)

11 + rev(97) = 11 + 79 = 90, 97 + rev(11) = 97 + 11 = 108. Not equal.

Code -

solution.c — C

#include <stdio.h>

int reverse(int x) {
    int result = 0;
    while (x > 0) {
        result = result * 10 + x % 10;
        x /= 10;
    }
    return result;
}

int countNicePairs(int* nums, int numsSize) {
    const int MOD = 1000000007;
    long long count = 0;
    
    for (int i = 0; i < numsSize; i++) {
        for (int j = i + 1; j < numsSize; j++) {
            if (nums[i] + reverse(nums[j]) == nums[j] + reverse(nums[i])) {
                count = (count + 1) % MOD;
            }
        }
    }
    
    return count;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We check all n*(n-1)/2 pairs, and for each pair we calculate reverses in O(log nums[i]) time

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁵
0 ≤ nums[i] ≤ 10⁹
Return the result modulo 10⁹ + 7

52.4K Views

Medium-High Frequency

~22 min Avg. Time

1.9K 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 All Pairs) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler