Welcome to Subscribe On Youtube

1814. Count Nice Pairs in an Array

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

Solution 1: Equation Transformation + Hash Table

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)$.

• Java
• C++
• Python
• Go
• TypeScript
• Javascript
• C#

• 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;
      }
  }
  

• 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 + 1ll * v * (v - 1) / 2) % mod;
          }
          return ans;
      }
  };
  

• 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
  
  

• 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
  }
  

• 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;
  }
  
  

• /**
   * @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;
  };
  
  

• 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)1e9 + 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;
      }
  }
  
  

All Problems

All Solutions