Count Almost Equal Pairs II - Practice Coding Problems

Count Almost Equal Pairs II - Problem

You're given an array of positive integers, and your task is to find pairs of numbers that are "almost equal" - meaning they can become identical through digit swapping operations.

Two integers x and y are considered almost equal if you can make them identical by performing at most 2 swap operations. In each operation, you can:

Choose either x or y
Swap any two digits within the chosen number

For example, 1234 and 3412 are almost equal because:

Swap digits at positions 0,2 in 1234 → 3214
Swap digits at positions 1,3 in 3214 → 3412

Goal: Count all pairs (i, j) where i < j and nums[i] and nums[j] are almost equal.

Note: Leading zeros are allowed after swapping operations.

Input & Output

example_1.py — Basic Case

$ Input: nums = [3, 12, 30, 17, 21]

› Output: 2

💡 Note: The almost equal pairs are (12, 21) and (30, 3). For (12, 21): swap positions 0,1 in 12 → 21. For (30, 3): swap positions 0,1 in 30 → 03 = 3.

example_2.py — Multiple Swaps

$ Input: nums = [1, 1, 1, 1, 1]

› Output: 10

💡 Note: All identical numbers are almost equal (requiring 0 swaps). With 5 identical numbers, we have C(5,2) = 10 pairs.

example_3.py — Complex Case

$ Input: nums = [1234, 2143, 1324, 4321]

› Output: 4

💡 Note: Multiple numbers can be transformed into each other with at most 2 swaps. For example, 1234 → 1324 (one swap), 1234 → 2143 (two swaps), etc.

Visualization

Tap to expand

Understanding the Visualization

Generate Variations

For each number, create all possible arrangements with 0, 1, or 2 swaps

Hash Storage

Store each variation in a hash map with its frequency count

Count Matches

For new numbers, check if any of their variations exist in the hash map

Accumulate Pairs

Sum up all the matching counts to get total almost equal pairs

Key Takeaway

🎯 Key Insight: Instead of comparing every pair directly (O(n²)), we transform the problem into a grouping problem where numbers that can reach the same variations are automatically paired together through hash map lookups.

Time & Space Complexity

Time Complexity

⏱️

O(n × d⁴)

n iterations, each generating O(d²) variations with O(d²) additional variations from 2-swaps, where d is number of digits

✓ Linear Growth

Space Complexity

O(n × d⁴)

Hash map stores all variations for all numbers processed

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 3000
1 ≤ nums[i] ≤ 10⁷
At most 2 swap operations allowed per number
Leading zeros are allowed after swapping

Asked in

G Google 42 a Amazon 35 f Meta 28 ⊞ Microsoft 23 Apple 18

The optimal solution uses a one-pass hash table approach where we generate all possible variations (0, 1, and 2 swaps) for each number and use a hash map to track previously seen variations. For each new number, we count how many of its variations have been encountered before, giving us the number of almost equal pairs. The key insight is that instead of comparing every pair directly, we can group numbers by their achievable forms and count intersections efficiently.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n² × d⁴)	O(d²)	Check every pair by trying all possible swap combinations
One-Pass Hash Table (Optimal)	O(n × d⁴)	O(n × d⁴)	Generate all variations for each number and use hash map to find matches in one pass

Brute Force (Nested Loops) — Algorithm Steps

Iterate through all pairs (i, j) where i < j
For each pair, check if nums[i] and nums[j] are already equal
Generate all 1-swap variations of nums[i] and check against nums[j]
Generate all 1-swap variations of nums[j] and check against nums[i]
Generate all 2-swap variations of both numbers and check for matches
Count pairs that can be made equal

Visualization

Tap to expand

Step-by-Step Walkthrough

Select Pair

Choose two numbers from the array

Generate Variations

Create all 0, 1, and 2-swap variations for both numbers

Check Intersection

See if any variations match between the two numbers

Count Match

If match found, increment counter

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>

#define MAX_VARIATIONS 10000

typedef struct {
    int values[MAX_VARIATIONS];
    int count;
} VariationSet;

bool hasIntersection(VariationSet* set1, VariationSet* set2) {
    for (int i = 0; i < set1->count; i++) {
        for (int j = 0; j < set2->count; j++) {
            if (set1->values[i] == set2->values[j]) {
                return true;
            }
        }
    }
    return false;
}

void addVariation(VariationSet* set, int value) {
    for (int i = 0; i < set->count; i++) {
        if (set->values[i] == value) return;
    }
    if (set->count < MAX_VARIATIONS) {
        set->values[set->count++] = value;
    }
}

VariationSet getAllVariations(int num) {
    VariationSet variations = {0};
    char s[20];
    sprintf(s, "%d", num);
    int n = strlen(s);
    
    addVariation(&variations, num);
    
    // 1 swap variations
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            char temp[20];
            strcpy(temp, s);
            char c = temp[i];
            temp[i] = temp[j];
            temp[j] = c;
            addVariation(&variations, atoi(temp));
        }
    }
    
    // 2 swap variations (simplified)
    int firstLevelCount = variations.count;
    for (int k = 0; k < firstLevelCount; k++) {
        char varS[20];
        sprintf(varS, "%0*d", n, variations.values[k]);
        int varLen = strlen(varS);
        
        for (int i = 0; i < varLen; i++) {
            for (int j = i + 1; j < varLen; j++) {
                char temp[20];
                strcpy(temp, varS);
                char c = temp[i];
                temp[i] = temp[j];
                temp[j] = c;
                addVariation(&variations, atoi(temp));
            }
        }
    }
    
    return variations;
}

int countPairs(int* nums, int numsSize) {
    int count = 0;
    
    for (int i = 0; i < numsSize; i++) {
        for (int j = i + 1; j < numsSize; j++) {
            VariationSet varsI = getAllVariations(nums[i]);
            VariationSet varsJ = getAllVariations(nums[j]);
            
            if (hasIntersection(&varsI, &varsJ)) {
                count++;
            }
        }
    }
    
    return count;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² × d⁴)

n² for all pairs, d⁴ for generating and comparing all swap combinations where d is number of digits

⚠ Quadratic Growth

Space Complexity

O(d²)

Space to store swap variations of a single number

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 3000
1 ≤ nums[i] ≤ 10⁷
At most 2 swap operations allowed per number
Leading zeros are allowed after swapping

43.7K Views

Medium-High Frequency

~25 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler