<p><strong>Attention</strong>: In this version, the number of operations that can be performed, has been increased to <strong>twice</strong>.<!-- notionvc: 278e7cb2-3b05-42fa-8ae9-65f5fd6f7585 --></p>

<p>You are given an array <code>nums</code> consisting of positive integers.</p>

<p>We call two integers <code>x</code> and <code>y</code> <strong>almost equal</strong> if both integers can become equal after performing the following operation <strong>at most <u>twice</u></strong>:</p>

<ul>
	<li>Choose <strong>either</strong> <code>x</code> or <code>y</code> and swap any two digits within the chosen number.</li>
</ul>

<p>Return the number of indices <code>i</code> and <code>j</code> in <code>nums</code> where <code>i &lt; j</code> such that <code>nums[i]</code> and <code>nums[j]</code> are <strong>almost equal</strong>.</p>

<p><strong>Note</strong> that it is allowed for an integer to have leading zeros after performing an operation.</p>

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

<div class="example-block">
<p><strong>Input:</strong> <span class="example-io">nums = [1023,2310,2130,213]</span></p>

<p><strong>Output:</strong> <span class="example-io">4</span></p>

<p><strong>Explanation:</strong></p>

<p>The almost equal pairs of elements are:</p>

<ul>
	<li>1023 and 2310. By swapping the digits 1 and 2, and then the digits 0 and 3 in 1023, you get 2310.</li>
	<li>1023 and 213. By swapping the digits 1 and 0, and then the digits 1 and 2 in 1023, you get 0213, which is 213.</li>
	<li>2310 and 213. By swapping the digits 2 and 0, and then the digits 3 and 2 in 2310, you get 0213, which is 213.</li>
	<li>2310 and 2130. By swapping the digits 3 and 1 in 2310, you get 2130.</li>
</ul>
</div>

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

<div class="example-block">
<p><strong>Input:</strong> <span class="example-io">nums = [1,10,100]</span></p>

<p><strong>Output:</strong> <span class="example-io">3</span></p>

<p><strong>Explanation:</strong></p>

<p>The almost equal pairs of elements are:</p>

<ul>
	<li>1 and 10. By swapping the digits 1 and 0 in 10, you get 01 which is 1.</li>
	<li>1 and 100. By swapping the second 0 with the digit 1 in 100, you get 001, which is 1.</li>
	<li>10 and 100. By swapping the first 0 with the digit 1 in 100, you get 010, which is 10.</li>
</ul>
</div>

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

<ul>
	<li><code>2 &lt;= nums.length &lt;= 5000</code></li>
	<li><code>1 &lt;= nums[i] &lt; 10<sup>7</sup></code></li>
</ul>

class Solution:
    def countPairs(self, nums: List[int]) -> int:
        # change at most twice: 
        # can use a map: generate all things after two changes, what about 0
        # can happen: with more zeros can covert to with less 0s
        # sort by 0 count: from more 0 to less 0s, then find!
        
        # arr = [(str(x).count('0'), x) for x in nums]
        # arr = sorted(arr, reverse=1)
        # nums2 = [x for (y, x) in arr]
        
        mp = Counter(nums)
        # mp = defaultdict(list)
        # for i, v in enumerate(nums):
        #     mp[v].append(i)
        # record only different number pairs
        res2 = 0
        
        # record for the same value, already happen: the count!
        # seen = dict()
        seen = set()
        for i, v in enumerate(nums):
            
            # if v in seen:
            #     continue
                
            # this_cnt = mp[v]
            # res2 += this_cnt * (this_cnt - 1) // 2
            
            lst = list(str(v))
            
            # generate all first level
            for j in range(len(lst)):
                for k in range(j+1, len(lst)):
                    lst[j], lst[k] = lst[k], lst[j]
                    new_i = ''.join(lst)
                    
                    if int(new_i) in mp and int(new_i) != v:
                        # record 
                        mi = min(v, int(new_i) )
                        mx = max(v, int(new_i) )
                        if (mi, mx) not in seen:
                            seen.add((mi, mx))
                        
                    lst[j], lst[k] = lst[k], lst[j]
                    
                    # based on new_i, do 2nd level swap
                    # print(new_i)
                    lst2 = list(new_i)
                    for j2 in range(len(lst2)):
                        for k2 in range(j2+1, len(lst2)):
                            lst2[j2], lst2[k2] = lst2[k2], lst2[j2]
                            new_i = ''.join(lst2)
                            if int(new_i) in mp and int(new_i) != v:
                                mi = min(v, int(new_i) )
                                mx = max(v, int(new_i) )
                                if (mi, mx) not in seen:
                                    seen.add((mi, mx))
                            lst2[j2], lst2[k2] = lst2[k2], lst2[j2]            
        
       
        for k in mp:
            res2 += mp[k] * (mp[k] - 1) // 2
        
        res = 0

        for mi,mx in seen:
            res += mp[mi] * mp[mx]
        
        # print(res // 2, res2)
        return res + res2
            
            
            
            
            
            
            
            
            
            
            
            
        
            
49341