Welcome to Subscribe On Youtube

1512. Number of Good Pairs

Description

Given an array of integers nums, return the number of good pairs.

A pair (i, j) is called good if nums[i] == nums[j] and i < j.

 

Example 1:

Input: nums = [1,2,3,1,1,3]
Output: 4
Explanation: There are 4 good pairs (0,3), (0,4), (3,4), (2,5) 0-indexed.

Example 2:

Input: nums = [1,1,1,1]
Output: 6
Explanation: Each pair in the array are good.

Example 3:

Input: nums = [1,2,3]
Output: 0

 

Constraints:

  • 1 <= nums.length <= 100
  • 1 <= nums[i] <= 100

Solutions

  • class Solution {
        public int numIdenticalPairs(int[] nums) {
            int ans = 0;
            int[] cnt = new int[101];
            for (int x : nums) {
                ans += cnt[x]++;
            }
            return ans;
        }
    }
    
  • class Solution {
    public:
        int numIdenticalPairs(vector<int>& nums) {
            int ans = 0;
            int cnt[101]{};
            for (int& x : nums) {
                ans += cnt[x]++;
            }
            return ans;
        }
    };
    
  • class Solution:
        def numIdenticalPairs(self, nums: List[int]) -> int:
            ans = 0
            cnt = Counter()
            for x in nums:
                ans += cnt[x]
                cnt[x] += 1
            return ans
    
    
  • func numIdenticalPairs(nums []int) (ans int) {
    	cnt := [101]int{}
    	for _, x := range nums {
    		ans += cnt[x]
    		cnt[x]++
    	}
    	return
    }
    
  • function numIdenticalPairs(nums: number[]): number {
        const cnt = new Array(101).fill(0);
        let ans = 0;
        for (const x of nums) {
            ans += cnt[x]++;
        }
        return ans;
    }
    
    
  • class Solution {
        /**
         * @param Integer[] $nums
         * @return Integer
         */
        function numIdenticalPairs($nums) {
            $arr = array_values(array_unique($nums));
            for ($i = 0; $i < count($nums); $i++) {
                $v[$nums[$i]] += 1;
            }
            $rs = 0;
            for ($j = 0; $j < count($arr); $j++) {
                $rs += ($v[$arr[$j]] * ($v[$arr[$j]] - 1)) / 2;
            }
            return $rs;
        }
    }
    
    
  • impl Solution {
        pub fn num_identical_pairs(nums: Vec<i32>) -> i32 {
            let mut cnt = [0; 101];
            let mut ans = 0;
            for &num in nums.iter() {
                ans += cnt[num as usize];
                cnt[num as usize] += 1;
            }
            ans
        }
    }
    
    
  • /**
     * @param {number[]} nums
     * @return {number}
     */
    var numIdenticalPairs = function (nums) {
        const cnt = Array(101).fill(0);
        let ans = 0;
        for (const x of nums) {
            ans += cnt[x]++;
        }
        return ans;
    };
    
    

All Problems

All Solutions