Count Almost Equal Pairs II

Count Almost Equal Pairs II - Problem

You are given an array nums consisting of positive integers. We call two integers x and y almost equal if both integers can become equal after performing the following operation at most twice:

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 that it is allowed for an integer to have leading zeros after performing an operation.

Input & Output

Example 1 — Basic Almost Equal

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

› Output: 2

💡 Note: The almost equal pairs are (12,21) - swap 1↔2 in 12 to get 21, and (30,3) - 30→03→3 with leading zero allowed

Example 2 — No Valid Pairs

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

› Output: 10

💡 Note: All numbers are identical, so all C(5,2) = 10 pairs are almost equal (0 swaps needed)

Example 3 — Complex Swapping

$ Input: nums = [123,321]

› Output: 1

💡 Note: Can make 123→321 with 2 swaps: 123→321 (swap positions 0↔2), so this pair is almost equal

Constraints

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

Visualization

Tap to expand

Asked in

G Google 15 f Meta 12 a Amazon 8

The key insight is that two numbers are almost equal if they have the same digit frequencies and their position differences can be resolved with at most 2 swaps. The optimized approach uses frequency analysis instead of generating all possible swap states. Time: O(n² × d), Space: O(d)

Common Approaches

✓ Brute Force with Swap Generation

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

Compare every pair of numbers by generating all possible states after 0, 1, or 2 swaps on each number. Check if any state of the first number matches any state of the second number.

Frequency Pattern Matching

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

First check if two numbers have the same digit frequencies. Then analyze position differences to determine if at most 2 swaps can make them equal. This avoids generating all possible states.

Brute Force with Swap Generation — Algorithm Steps

For each pair (i,j) where i < j
Generate all possible states after swaps for nums[i]
Generate all possible states after swaps for nums[j]
Check if any state from first set matches any from second set

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate States

Create all possible numbers after 0, 1, or 2 swaps

Compare Pairs

Check if any state from first number matches any state from second

Count Matches

Increment counter when intersection found

Code -

solution.c — C

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

#define MAX_STATES 1000
#define MAX_LEN 20

int getAllStates(int num, char states[][MAX_LEN]) {
    char s[MAX_LEN];
    sprintf(s, "%d", num);
    int stateCount = 0;
    strcpy(states[stateCount++], s);
    
    int len = strlen(s);
    
    // 1 swap
    for (int i = 0; i < len; i++) {
        for (int j = i + 1; j < len; j++) {
            char newState[MAX_LEN];
            strcpy(newState, s);
            char temp = newState[i];
            newState[i] = newState[j];
            newState[j] = temp;
            
            // Check if already exists
            int exists = 0;
            for (int k = 0; k < stateCount; k++) {
                if (strcmp(states[k], newState) == 0) {
                    exists = 1;
                    break;
                }
            }
            if (!exists && stateCount < MAX_STATES) {
                strcpy(states[stateCount++], newState);
            }
            
            // 2nd swap
            for (int x = 0; x < len; x++) {
                for (int y = x + 1; y < len; y++) {
                    char finalState[MAX_LEN];
                    strcpy(finalState, newState);
                    char temp2 = finalState[x];
                    finalState[x] = finalState[y];
                    finalState[y] = temp2;
                    
                    exists = 0;
                    for (int k = 0; k < stateCount; k++) {
                        if (strcmp(states[k], finalState) == 0) {
                            exists = 1;
                            break;
                        }
                    }
                    if (!exists && stateCount < MAX_STATES) {
                        strcpy(states[stateCount++], finalState);
                    }
                }
            }
        }
    }
    
    return stateCount;
}

int solution(int* nums, int numsSize) {
    int count = 0;
    
    for (int i = 0; i < numsSize; i++) {
        for (int j = i + 1; j < numsSize; j++) {
            char statesI[MAX_STATES][MAX_LEN];
            char statesJ[MAX_STATES][MAX_LEN];
            
            int countI = getAllStates(nums[i], statesI);
            int countJ = getAllStates(nums[j], statesJ);
            
            // Check intersection
            int found = 0;
            for (int x = 0; x < countI && !found; x++) {
                for (int y = 0; y < countJ; y++) {
                    if (strcmp(statesI[x], statesJ[y]) == 0) {
                        count++;
                        found = 1;
                        break;
                    }
                }
            }
        }
    }
    
    return count;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse JSON array manually
    int nums[1000];
    int size = 0;
    char* ptr = strchr(line, '[');
    if (ptr) {
        ptr++;
        char* token = strtok(ptr, ",]");
        while (token != NULL) {
            nums[size++] = atoi(token);
            token = strtok(NULL, ",]");
        }
    }
    
    int result = solution(nums, size);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² × d⁴)

n² pairs, each requiring O(d⁴) operations where d is digits per number

⚠ Quadratic Growth

Space Complexity

O(d⁴)

Stores all possible swap states for two numbers

✓ Linear Space

8.5K Views

Medium Frequency

~35 min Avg. Time

180 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force with Swap Generation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler