Array
Hash Table
Math
Counting
Description
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 109 + 7
.
Example 1:
Input: nums = [42,11,1,97]
Output: 2
Explanation: The two pairs are:
- (0,3) : 42 + rev(97) = 42 + 79 = 121, 97 + rev(42) = 97 + 24 = 121.
- (1,2) : 11 + rev(1) = 11 + 1 = 12, 1 + rev(11) = 1 + 11 = 12.
Example 2:
Input: nums = [13,10,35,24,76]
Output: 4
Constraints:
1 <= nums.length <= 105
0 <= nums[i] <= 109
Solutions
For the index pair $(i, j)$, if it satisfies the condition, then we have $nums[i] + rev(nums[j]) = nums[j] + rev(nums[i])$, which means $nums[i] - nums[j] = rev(nums[j]) - rev(nums[i])$.
Therefore, we can use $nums[i] - rev(nums[i])$ as the key of a hash table and count the number of occurrences of each key. Finally, we calculate the combination of values corresponding to each key, add them up, and get the final answer.
Note that we need to perform modulo operation on the answer.
The time complexity is $O(n \times \log M)$, where $n$ and $M$ are the length of the $nums$ array and the maximum value in the $nums$ array, respectively. The space complexity is $O(n)$.
Python3 Java C++ Go TypeScript JavaScript C#
1
2
3
4
5
6
7
8
9
10
11
12 class Solution :
def countNicePairs ( self , nums : List [ int ]) -> int :
def rev ( x ):
y = 0
while x :
y = y * 10 + x % 10
x //= 10
return y
cnt = Counter ( x - rev ( x ) for x in nums )
mod = 10 ** 9 + 7
return sum ( v * ( v - 1 ) // 2 for v in cnt . values ()) % mod
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23 class Solution {
public int countNicePairs ( int [] nums ) {
Map < Integer , Integer > cnt = new HashMap <> ();
for ( int x : nums ) {
int y = x - rev ( x );
cnt . merge ( y , 1 , Integer :: sum );
}
final int mod = ( int ) 1e9 + 7 ;
long ans = 0 ;
for ( int v : cnt . values ()) {
ans = ( ans + ( long ) v * ( v - 1 ) / 2 ) % mod ;
}
return ( int ) ans ;
}
private int rev ( int x ) {
int y = 0 ;
for (; x > 0 ; x /= 10 ) {
y = y * 10 + x % 10 ;
}
return y ;
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23 class Solution {
public :
int countNicePairs ( vector < int >& nums ) {
auto rev = []( int x ) {
int y = 0 ;
for (; x > 0 ; x /= 10 ) {
y = y * 10 + x % 10 ;
}
return y ;
};
unordered_map < int , int > cnt ;
for ( int & x : nums ) {
int y = x - rev ( x );
cnt [ y ] ++ ;
}
long long ans = 0 ;
const int mod = 1e9 + 7 ;
for ( auto & [ _ , v ] : cnt ) {
ans = ( ans + 1l l * v * ( v - 1 ) / 2 ) % mod ;
}
return ans ;
}
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18 func countNicePairs ( nums [] int ) ( ans int ) {
rev := func ( x int ) ( y int ) {
for ; x > 0 ; x /= 10 {
y = y * 10 + x % 10
}
return
}
cnt := map [ int ] int {}
for _ , x := range nums {
y := x - rev ( x )
cnt [ y ] ++
}
const mod int = 1e9 + 7
for _ , v := range cnt {
ans = ( ans + v * ( v - 1 ) / 2 ) % mod
}
return
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 function countNicePairs ( nums : number []) : number {
const rev = ( x : number ) : number => {
let y = 0 ;
while ( x ) {
y = y * 10 + ( x % 10 );
x = Math . floor ( x / 10 );
}
return y ;
};
const mod = 10 ** 9 + 7 ;
const cnt = new Map < number , number > ();
let ans = 0 ;
for ( const x of nums ) {
const y = x - rev ( x );
ans = ( ans + ( cnt . get ( y ) ?? 0 )) % mod ;
cnt . set ( y , ( cnt . get ( y ) ?? 0 ) + 1 );
}
return ans ;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24 /**
* @param {number[]} nums
* @return {number}
*/
var countNicePairs = function ( nums ) {
const rev = x => {
let y = 0 ;
for (; x > 0 ; x = Math . floor ( x / 10 )) {
y = y * 10 + ( x % 10 );
}
return y ;
};
const cnt = new Map ();
for ( const x of nums ) {
const y = x - rev ( x );
cnt . set ( y , ( cnt . get ( y ) | 0 ) + 1 );
}
let ans = 0 ;
const mod = 1e9 + 7 ;
for ( const [ _ , v ] of cnt ) {
ans = ( ans + Math . floor (( v * ( v - 1 )) / 2 )) % mod ;
}
return ans ;
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24 public class Solution {
public int CountNicePairs ( int [] nums ) {
Dictionary < int , int > cnt = new Dictionary < int , int > ();
foreach ( int x in nums ) {
int y = x - Rev ( x );
cnt [ y ] = cnt . GetValueOrDefault ( y , 0 ) + 1 ;
}
int mod = ( int ) 1 e9 + 7 ;
long ans = 0 ;
foreach ( int v in cnt . Values ) {
ans = ( ans + ( long ) v * ( v - 1 ) / 2 ) % mod ;
}
return ( int ) ans ;
}
private int Rev ( int x ) {
int y = 0 ;
while ( x > 0 ) {
y = y * 10 + x % 10 ;
x /= 10 ;
}
return y ;
}
}
Solution 2
GitHub