Count Nice Pairs in an Array - Practice Coding Problems

Count Nice Pairs in an Array - Problem

You are given an array nums that consists of non-negative integers. Let us define rev(x) as the reverse of the non-negative integer x. For example, rev(123) = 321, and rev(120) = 21.

A pair of indices (i, j) is nice if it satisfies all of the following conditions:

0 <= i < j < nums.length
nums[i] + rev(nums[j]) == nums[j] + rev(nums[i])

Return the number of nice pairs of indices. Since that number can be too large, return it modulo 10⁹ + 7.

Input & Output

Example 1 — Basic Case

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

› Output: 2

💡 Note: The two 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 — Single Nice Pair

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

› Output: 4

💡 Note: Multiple pairs satisfy the nice condition when nums[i] - rev(nums[i]) equals nums[j] - rev(nums[j]).

Example 3 — No Nice Pairs

$ Input: nums = [123,456]

› Output: 0

💡 Note: 123 + rev(456) = 123 + 654 = 777, but 456 + rev(123) = 456 + 321 = 777. Actually this is a nice pair! The difference approach: 123-321=-198, 456-654=-198, so they have same difference and form 1 nice pair.

Constraints

1 ≤ nums.length ≤ 10⁵
0 ≤ nums[i] ≤ 10⁹

Visualization

Tap to expand

Understanding the Visualization

Input Array

[42, 11, 1, 97] - find nice pairs

Transform

Calculate num - reverse(num) for each element

Count Pairs

Elements with same difference form nice pairs

Key Takeaway

🎯 Key Insight: Transform the equation to find elements with the same difference value

Asked in

F Facebook 25 G Google 18

The key insight is transforming the equation nums[i] + rev(nums[j]) = nums[j] + rev(nums[i]) into nums[i] - rev(nums[i]) = nums[j] - rev(nums[j]). Best approach uses hash map frequency counting. Time: O(n), Space: O(n)

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force	O(n²)	O(1)	Check every pair of indices to see if they form a nice pair
Hash Map with Frequency Count	O(n)	O(n)	Transform equation and count frequencies of differences

Brute Force — Algorithm Steps

Iterate through all pairs (i,j) where i < j
For each pair, reverse both numbers
Check if nums[i] + rev(nums[j]) == nums[j] + rev(nums[i])
Count valid pairs and return modulo 10^9 + 7

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Pair (0,1)

nums[0] + rev(nums[1]) vs nums[1] + rev(nums[0])

Check Pair (0,2)

Continue with next pair

Count Valid

Increment counter for each nice pair found

Code -

solution.c — C

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

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

int solution(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] + reverseNum(nums[j]) == nums[j] + reverseNum(nums[i])) {
                count = (count + 1) % MOD;
            }
        }
    }
    
    return (int)count;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Nested loops check all pairs - outer loop runs n times, inner loop runs up to n times

⚠ Quadratic Growth

Space Complexity

O(1)

Only uses constant extra variables for counting and calculations

✓ Linear Space

24.3K Views

Medium Frequency

~15 min Avg. Time

892 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

Brute Force — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler