Count Almost Equal Pairs I - Practice Coding Problems

Count Almost Equal Pairs I - Problem

You are given an array nums of positive integers. Your task is to count pairs of numbers that are "almost equal" - meaning they can become identical with at most one strategic digit swap!

What makes two numbers "almost equal"?

They are already identical, OR
You can pick either number and swap any two of its digits to make them equal

Goal: Return the number of valid pairs (i, j) where i < j and nums[i] and nums[j] are almost equal.

Example: Numbers 123 and 132 are almost equal because swapping digits 2 and 3 in 132 gives us 123.

Note: Leading zeros are allowed after swapping (e.g., 102 can become 021).

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 and 21: swap digits in 12 to get 21. For 30 and 3: 30 becomes 03 which equals 3 when leading zeros are ignored.

example_2.py — No Pairs

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

› Output: 10

💡 Note: All numbers are identical, so every pair (i,j) where i < j is almost equal. With 5 identical numbers, we have C(5,2) = 10 pairs.

example_3.py — Complex Swaps

$ Input: nums = [123,231,111,112]

› Output: 4

💡 Note: Pairs: (123,231) - swap 1,3 in 123 to get 321, then 2,1 to get 231. Actually, we can get 132, 213, 321 from 123 by single swaps. 231 can be made from 123 by swapping positions 0 and 1.

Visualization

Tap to expand

Understanding the Visualization

Identify Patterns

For each lock, list all combinations it can achieve with one swap

Group Compatible Locks

Locks that can achieve the same combinations are almost equal

Count Pairs

Within each group of n compatible locks, there are n×(n-1)/2 pairs

Key Takeaway

🎯 Key Insight: Instead of comparing every pair directly, we group numbers by their 'reachable patterns' using hash maps, turning an O(n² × d³) problem into O(n × d²)!

Time & Space Complexity

Time Complexity

⏱️

O(n × d²)

For each of n numbers, we generate O(d²) possible swaps where d is the number of digits

✓ Linear Growth

Space Complexity

O(n × d²)

Hash map stores all possible patterns for all numbers

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 100
1 ≤ nums[i] ≤ 10⁶
Leading zeros are allowed after swapping
Numbers can have different lengths and still be almost equal

Asked in

G Google 45 f Meta 32 a Amazon 28 ⊞ Microsoft 22

The optimal solution uses a hash map approach where we generate all possible single-digit swap variants for each number and group them by patterns. Numbers that can create the same pattern through swaps are almost equal. This reduces time complexity from O(n² × d³) to O(n × d²) where d is the number of digits.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n² × d³)	O(d)	Check every pair of numbers by trying all possible digit swaps
Hash Map with Digit Pattern Matching	O(n × d²)	O(n × d²)	Use hash map to group numbers by their possible digit swap patterns

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
If not equal, try all possible digit swaps on nums[i] to see if it matches nums[j]
If still no match, try all possible digit swaps on nums[j] to see if it matches nums[i]
Count valid pairs

Visualization

Tap to expand

Step-by-Step Walkthrough

Select Pair

Pick two numbers from the array to compare

Direct Compare

Check if they are already equal

Try Swaps

Attempt all possible digit swaps on both numbers

Count Match

If any swap creates a match, increment counter

Code -

solution.c — C

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

int areAlmostEqual(int x, int y) {
    if (x == y) return 1;
    
    char xStr[12], yStr[12];
    sprintf(xStr, "%d", x);
    sprintf(yStr, "%d", y);
    
    int xLen = strlen(xStr);
    int yLen = strlen(yStr);
    
    // Try swapping digits in x
    for (int i = 0; i < xLen; i++) {
        for (int j = i + 1; j < xLen; j++) {
            char temp = xStr[i];
            xStr[i] = xStr[j];
            xStr[j] = temp;
            if (atoi(xStr) == y) return 1;
            // Swap back
            xStr[j] = xStr[i];
            xStr[i] = temp;
        }
    }
    
    // Try swapping digits in y
    for (int i = 0; i < yLen; i++) {
        for (int j = i + 1; j < yLen; j++) {
            char temp = yStr[i];
            yStr[i] = yStr[j];
            yStr[j] = temp;
            if (atoi(yStr) == x) return 1;
            // Swap back
            yStr[j] = yStr[i];
            yStr[i] = temp;
        }
    }
    
    return 0;
}

int countPairs(int* nums, int numsSize) {
    int count = 0;
    
    for (int i = 0; i < numsSize; i++) {
        for (int j = i + 1; j < numsSize; j++) {
            if (areAlmostEqual(nums[i], nums[j])) {
                count++;
            }
        }
    }
    
    return count;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² × d³)

n² pairs to check, and for each pair we try O(d²) swaps, each taking O(d) time to process

⚠ Quadratic Growth

Space Complexity

O(d)

Only need space to store digit arrays for comparison

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 100
1 ≤ nums[i] ≤ 10⁶
Leading zeros are allowed after swapping
Numbers can have different lengths and still be almost equal

38.2K Views

Medium Frequency

~18 min Avg. Time

1.2K 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