Count Number of Bad Pairs - Practice Coding Problems

Count Number of Bad Pairs - Problem

Given a 0-indexed integer array nums, you need to count pairs of indices that don't maintain a consistent relationship.

A pair of indices (i, j) where i < j is considered a "bad pair" if the difference between their indices doesn't equal the difference between their values. In mathematical terms: j - i ≠ nums[j] - nums[i].

Goal: Return the total count of bad pairs in the array.

Example: In array [4, 1, 3, 3], the pair (0, 1) is bad because 1 - 0 = 1 but nums[1] - nums[0] = 1 - 4 = -3, and 1 ≠ -3.

Input & Output

example_1.py — Python

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

› Output: 5

💡 Note: Check all pairs: (0,1): 1-0=1, 1-4=-3, 1≠-3 ✗ | (0,2): 2-0=2, 3-4=-1, 2≠-1 ✗ | (0,3): 3-0=3, 3-4=-1, 3≠-1 ✗ | (1,2): 2-1=1, 3-1=2, 1≠2 ✗ | (1,3): 3-1=2, 3-1=2, 2=2 ✓ | (2,3): 3-2=1, 3-3=0, 1≠0 ✗. Total bad pairs: 5

example_2.py — Python

$ Input: nums = [1,2,3,4,5]

› Output: 0

💡 Note: This is an arithmetic sequence with difference 1. For any pair (i,j): j-i equals nums[j]-nums[i] because both equal j-i. All pairs are good, so bad pairs = 0.

example_3.py — Python

$ Input: nums = [1]

› Output: 0

💡 Note: Array has only one element. No pairs possible, so bad pairs = 0.

Visualization

Tap to expand

Understanding the Visualization

Original Problem

Count pairs where j - i ≠ nums[j] - nums[i]

Transform Equation

Rewrite as: good pairs satisfy nums[i] - i = nums[j] - j

Count Good Pairs

Use hash map to count frequencies and calculate combinations

Get Answer

Bad pairs = Total pairs - Good pairs

Key Takeaway

🎯 Key Insight: Transform the inequality to find good pairs easily, then subtract from total pairs!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array to build frequency map and calculate result

✓ Linear Growth

Space Complexity

O(n)

Hash map to store frequency of transformed values, worst case all unique

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹
i < j (only count pairs where first index is smaller)

Asked in

G Google 15 a Amazon 12 f Meta 8 ⊞ Microsoft 6

The optimal solution uses a clever mathematical transformation: instead of checking j - i ≠ nums[j] - nums[i], we find good pairs where nums[i] - i = nums[j] - j. By counting frequencies in a hash map, we calculate good pairs in O(n) time, then subtract from total pairs to get bad pairs.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Hash Table (Optimal)	O(n)	O(n)	Transform equation and count good pairs, then subtract from total pairs
Brute Force (Nested Loops)	O(n²)	O(1)	Check every pair (i,j) to see if j - i != nums[j] - nums[i]

One-Pass Hash Table (Optimal) — Algorithm Steps

Transform condition: good pairs have nums[i] - i = nums[j] - j
Use hash map to count frequency of each (nums[i] - i) value
For each group with count c, it contributes c*(c-1)/2 good pairs
Calculate total possible pairs: n*(n-1)/2
Return total pairs - good pairs = bad pairs

Visualization

Tap to expand

Step-by-Step Walkthrough

Transform Values

For each nums[i], calculate nums[i] - i

Count Frequencies

Use hash map to count frequency of each transformed value

Calculate Good Pairs

For each frequency count c, add c*(c-1)/2 good pairs

Get Bad Pairs

Subtract good pairs from total pairs n*(n-1)/2

Code -

solution.c — C

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

// Simple hash table for this problem
#define MAX_SIZE 1000
typedef struct {
    int key;
    int value;
    int used;
} HashEntry;

HashEntry table[MAX_SIZE];

int hash(int key) {
    return abs(key) % MAX_SIZE;
}

void put(int key, int value) {
    int index = hash(key);
    while (table[index].used && table[index].key != key) {
        index = (index + 1) % MAX_SIZE;
    }
    table[index].key = key;
    table[index].value = value;
    table[index].used = 1;
}

int get(int key) {
    int index = hash(key);
    while (table[index].used) {
        if (table[index].key == key) {
            return table[index].value;
        }
        index = (index + 1) % MAX_SIZE;
    }
    return 0;
}

int countBadPairs(int* nums, int n) {
    // Initialize hash table
    for (int i = 0; i < MAX_SIZE; i++) {
        table[i].used = 0;
    }
    
    // Count frequency of (nums[i] - i)
    for (int i = 0; i < n; i++) {
        int key = nums[i] - i;
        put(key, get(key) + 1);
    }
    
    // Count good pairs
    int goodPairs = 0;
    for (int i = 0; i < MAX_SIZE; i++) {
        if (table[i].used) {
            int count = table[i].value;
            goodPairs += count * (count - 1) / 2;
        }
    }
    
    // Total pairs - good pairs = bad pairs
    int totalPairs = n * (n - 1) / 2;
    return totalPairs - goodPairs;
}

int main() {
    int nums[] = {4, 1, 3, 3};
    int n = 4;
    printf("%d\n", countBadPairs(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array to build frequency map and calculate result

✓ Linear Growth

Space Complexity

O(n)

Hash map to store frequency of transformed values, worst case all unique

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹
i < j (only count pairs where first index is smaller)

42.0K Views

Medium Frequency

~18 min Avg. Time

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

One-Pass Hash Table (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler