<p>You are given a <strong>0-indexed</strong> positive integer array <code>nums</code> and a positive integer <code>k</code>.</p>

<p>A pair of numbers <code>(num1, num2)</code> is called <strong>excellent</strong> if the following conditions are satisfied:</p>

<ul>
	<li><strong>Both</strong> the numbers <code>num1</code> and <code>num2</code> exist in the array <code>nums</code>.</li>
	<li>The sum of the number of set bits in <code>num1 OR num2</code> and <code>num1 AND num2</code> is greater than or equal to <code>k</code>, where <code>OR</code> is the bitwise <strong>OR</strong> operation and <code>AND</code> is the bitwise <strong>AND</strong> operation.</li>
</ul>

<p>Return <em>the number of <strong>distinct</strong> excellent pairs</em>.</p>

<p>Two pairs <code>(a, b)</code> and <code>(c, d)</code> are considered distinct if either <code>a != c</code> or <code>b != d</code>. For example, <code>(1, 2)</code> and <code>(2, 1)</code> are distinct.</p>

<p><strong>Note</strong> that a pair <code>(num1, num2)</code> such that <code>num1 == num2</code> can also be excellent if you have at least <strong>one</strong> occurrence of <code>num1</code> in the array.</p>

<p>&nbsp;</p>
<p><strong class="example">Example 1:</strong></p>

<pre>
<strong>Input:</strong> nums = [1,2,3,1], k = 3
<strong>Output:</strong> 5
<strong>Explanation:</strong> The excellent pairs are the following:
- (3, 3). (3 AND 3) and (3 OR 3) are both equal to (11) in binary. The total number of set bits is 2 + 2 = 4, which is greater than or equal to k = 3.
- (2, 3) and (3, 2). (2 AND 3) is equal to (10) in binary, and (2 OR 3) is equal to (11) in binary. The total number of set bits is 1 + 2 = 3.
- (1, 3) and (3, 1). (1 AND 3) is equal to (01) in binary, and (1 OR 3) is equal to (11) in binary. The total number of set bits is 1 + 2 = 3.
So the number of excellent pairs is 5.</pre>

<p><strong class="example">Example 2:</strong></p>

<pre>
<strong>Input:</strong> nums = [5,1,1], k = 10
<strong>Output:</strong> 0
<strong>Explanation:</strong> There are no excellent pairs for this array.
</pre>

<p>&nbsp;</p>
<p><strong>Constraints:</strong></p>

<ul>
	<li><code>1 &lt;= nums.length &lt;= 10<sup>5</sup></code></li>
	<li><code>1 &lt;= nums[i] &lt;= 10<sup>9</sup></code></li>
	<li><code>1 &lt;= k &lt;= 60</code></li>
</ul>

class Solution:
    def countExcellentPairs(self, nums: List[int], k: int) -> int:
        '''
        * number of distinct pairs that are excellent
        * a pair is excellent if num1 OR num2 + (num1 AND num2) >= k 
        * all integers in nums and k are all positive
        * a number can pair with itself
        ===
        * basically bitwise addition of nums1 and nums2 must be >= k
        * this would mean that combined set bits in set_bits(nums1) + set_bit(nums2) >= k => works! but slow.. also hints suggests the same approach! 
        '''

        def bk(n): 
            cnt = 0 
            while n: 
                n = n & (n -1)
                cnt += 1
            return cnt

        nums = set(nums) # keep only the unique.. to count for uniq pairs..
        bit_set_num_cnt = collections.defaultdict(int)
        for n in nums: 
            cnt = bk(n)
            ### naive counting:
            # cnt = collections.Counter((bin(n)[2:]))["1"]
            bit_set_num_cnt[cnt] += 1
        
        pairs = 0
        for bs1 in bit_set_num_cnt: 
            for bs2 in bit_set_num_cnt: # pick any two number and check if the bits that are set is >= k 
                summ = bs1 + bs2
                if summ >= k: # then I know for sure at least one bit is set in nums1 + nums2 equal to or to the left of leftmost set bit in k.. making sum of number of set bits >= k 
                    pairs += bit_set_num_cnt[bs1] * bit_set_num_cnt[bs2] # how many numbers do I have with bs1 bits set? and how many numbers do I have with bs2 bit set? these can form excellent pairs with each other.. 

        return pairs







        # #### not quite right: num to set bits mapping.. 
        # nums = set(nums) # keep only the unique.. to count for uniq pairs..
        # num_bit_set = collections.defaultdict(int)
        # for n in nums: 
        #     num_bit_set[n] = collections.Counter((bin(n)[2:]))["1"]
        
        # pairs = 0
        # for num1 in num_bit_set: 
        #     for num2 in num_bit_set: # pick any two number and check if the bits that are set is >= k 
        #         summ = num1 + num2
        #         if summ >= k: # then I know for sure at least one bit is set in nums1 + nums2 equal to or to the left of leftmost set bit in k.. making sum of number of set bits >= k 
        #             pairs += num_bit_set[num1] * num_bit_set[num2]

        # return pairs
680