Count Almost Equal Pairs I

Count Almost Equal Pairs I - Problem

You are given an array nums consisting of positive integers.

We call two integers x and y in this problem almost equal if both integers can become equal after performing the following operation at most once:

Choose either x or y and swap any two digits within the chosen number.

Return the number of indices i and j in nums where i < j such that nums[i] and nums[j] are almost equal.

Note: It is allowed for an integer to have leading zeros after performing an operation.

Input & Output

Example 1 — Basic Case

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

› Output: 2

💡 Note: Almost equal pairs: (12,21) because 12→21 by swapping digits, and (30,3) because 30→03→3 by swapping. Total count is 2.

Example 2 — No Swaps Needed

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

› Output: 10

💡 Note: All numbers are already equal, so every pair (i,j) where i

Example 3 — No Almost Equal Pairs

$ Input: nums = [123,456]

› Output: 0

💡 Note: No way to make 123 and 456 equal by swapping digits in either number.

Constraints

1 ≤ nums.length ≤ 100
1 ≤ nums[i] ≤ 10⁶

Visualization

Tap to expand

Asked in

G Google 25 M Microsoft 20 a Amazon 15

The key insight is that two numbers are almost equal if they differ in at most 2 digit positions and those digits can be swapped to make them equal. The optimized approach directly compares digit differences instead of generating all possible swaps. Time: O(n² × d), Space: O(d).

Common Approaches

✓ Prefix Sum

⏱️ Time: N/A Space: N/A

Brute Force - Check All Pairs

⏱️ Time: O(n² × d³) Space: O(d)

Compare every pair of numbers in the array. For each pair, convert to strings and check if they're already equal or if swapping any two digits in either number can make them equal.

Optimized - Efficient Digit Difference Check

⏱️ Time: O(n² × d) Space: O(d)

Instead of trying all possible swaps, compare the digits directly. Two numbers are almost equal if they differ in at most 2 positions, and the differing digits can be swapped to make them equal.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

// Function to convert number to string with leading zeros to match length
void numberToString(int num, char* str, int len) {
    sprintf(str, "%0*d", len, num);
}

// Function to check if two numbers are almost equal
bool areAlmostEqual(int a, int b) {
    // Convert numbers to strings with same length (padded with zeros)
    char strA[12], strB[12];
    int lenA = snprintf(NULL, 0, "%d", a);
    int lenB = snprintf(NULL, 0, "%d", b);
    int maxLen = lenA > lenB ? lenA : lenB;
    
    numberToString(a, strA, maxLen);
    numberToString(b, strB, maxLen);
    
    // If already equal
    if (strcmp(strA, strB) == 0) {
        return true;
    }
    
    // Try all possible single swaps in strA
    for (int i = 0; i < maxLen; i++) {
        for (int j = i + 1; j < maxLen; j++) {
            // Swap digits i and j in strA
            char temp = strA[i];
            strA[i] = strA[j];
            strA[j] = temp;
            
            if (strcmp(strA, strB) == 0) {
                return true;
            }
            
            // Swap back
            strA[j] = strA[i];
            strA[i] = temp;
        }
    }
    
    // Try all possible single swaps in strB
    for (int i = 0; i < maxLen; i++) {
        for (int j = i + 1; j < maxLen; j++) {
            // Swap digits i and j in strB
            char temp = strB[i];
            strB[i] = strB[j];
            strB[j] = temp;
            
            if (strcmp(strA, strB) == 0) {
                return true;
            }
            
            // Swap back
            strB[j] = strB[i];
            strB[i] = temp;
        }
    }
    
    return false;
}

int main() {
    char input[10000];
    fgets(input, sizeof(input), stdin);
    
    // Parse array from input like [3,12,30,17,21]
    int nums[1000];
    int count = 0;
    
    char* ptr = input;
    while (*ptr && *ptr != '[') ptr++; // Find opening bracket
    if (*ptr) ptr++; // Skip opening bracket
    
    while (*ptr && *ptr != ']') {
        while (*ptr == ' ' || *ptr == ',') ptr++; // Skip spaces and commas
        if (*ptr >= '0' && *ptr <= '9') {
            nums[count] = 0;
            while (*ptr >= '0' && *ptr <= '9') {
                nums[count] = nums[count] * 10 + (*ptr - '0');
                ptr++;
            }
            count++;
        } else {
            ptr++;
        }
    }
    
    // Count almost equal pairs
    int result = 0;
    for (int i = 0; i < count; i++) {
        for (int j = i + 1; j < count; j++) {
            if (areAlmostEqual(nums[i], nums[j])) {
                result++;
            }
        }
    }
    
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚠ Quadratic Growth

Space Complexity

✓ Linear Space

28.0K Views

Medium Frequency

~25 min Avg. Time

890 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