Find the Distance Value Between Two Arrays

Find the Distance Value Between Two Arrays - Problem

Find the Distance Value Between Two Arrays

You are given two integer arrays arr1 and arr2, along with an integer d representing a distance threshold. Your task is to find the distance value between these two arrays.

The distance value is defined as the count of elements arr1[i] such that there is no element arr2[j] where the absolute difference |arr1[i] - arr2[j]| is less than or equal to d.

In simpler terms, for each element in arr1, check if it's "far enough" (distance > d) from all elements in arr2. Count how many such "isolated" elements exist.

Example:
If arr1 = [4, 5, 8], arr2 = [10, 9, 1, 8], and d = 2:
• Element 4: distances to arr2 are [6, 5, 3, 4] - all > 2 ✓
• Element 5: distances to arr2 are [5, 4, 4, 3] - all > 2 ✓
• Element 8: distances to arr2 are [2, 1, 7, 0] - some ≤ 2 ✗

Result: 2 elements (4 and 5) satisfy the condition.

Input & Output

example_1.py — Basic Case

$ Input: arr1 = [4,5,8], arr2 = [10,9,1,8], d = 2

› Output: 2

💡 Note: For arr1[0]=4: distances are [6,5,3,4] - all > 2 ✓. For arr1[1]=5: distances are [5,4,4,3] - all > 2 ✓. For arr1[2]=8: distances are [2,1,7,0] - some ≤ 2 ✗. Count = 2.

example_2.py — All Valid

$ Input: arr1 = [1,4,2,3], arr2 = [-4,-3,6,10,20,30], d = 3

› Output: 4

💡 Note: Every element in arr1 is more than distance 3 from all elements in arr2. All 4 elements are counted.

example_3.py — None Valid

$ Input: arr1 = [2,1,100,3], arr2 = [-5,-2,10,-3,7], d = 6

› Output: 1

💡 Note: Only 100 is far enough from all elements in arr2. Elements 2,1,3 are all within distance 6 of some element in arr2.

Constraints

1 ≤ arr1.length, arr2.length ≤ 500
-1000 ≤ arr1[i], arr2[j] ≤ 1000
0 ≤ d ≤ 100
Elements can be negative
d can be 0 (only exact matches invalidate)

Visualization

Tap to expand

Understanding the Visualization

Map the Territory

Sort arr2 to create an organized map of factory locations: [1,8,9,10]

Check Each House

For each potential house location in arr1, use binary search to quickly find nearest factories

Measure Distances

Check only the closest neighbors instead of measuring to every single factory

Count Safe Houses

If all nearby factories are beyond distance d, the house is safe to buy

Key Takeaway

🎯 Key Insight: By sorting arr2 first, we transform an O(n×m) problem into O(m log m + n log m), using binary search to find closest elements instead of checking every pair.

Asked in

a Amazon 45 G Google 38 ⊞ Microsoft 32 f Meta 25

The optimal approach uses sorting + binary search to achieve O(m log m + n log m) time complexity. By sorting arr2 first, we can use binary search to quickly find the closest elements to each arr1[i], then check only the immediate neighbors instead of all elements. This is much more efficient than the O(n×m) brute force approach for large arrays.

Common Approaches

Approach	Time	Space	Notes
✓ Sorting + Binary Search	O(m log m + n log m)	O(1)	Sort arr2, then use binary search to find closest elements efficiently
Brute Force (Nested Loops)	O(n × m)	O(1)	For each element in arr1, check distance to every element in arr2

Sorting + Binary Search — Algorithm Steps

Sort arr2 in ascending order
Initialize count = 0
For each element arr1[i]:
Use binary search to find insertion position in arr2
Check the closest elements (left and right neighbors)
If all close neighbors have distance > d: increment count
Return count

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort arr2

Sort arr2: [10,9,1,8] → [1,8,9,10]

Search for 4

Binary search finds position 1 (between 1 and 8). Check neighbors: |4-1|=3>2, |4-8|=4>2 ✓

Search for 8

Binary search finds exact match at position 1. Distance |8-8|=0≤2 ✗

Code -

solution.c — C

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

int compare(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

int binarySearch(int* arr, int size, int target) {
    int left = 0, right = size;
    while (left < right) {
        int mid = left + (right - left) / 2;
        if (arr[mid] < target) left = mid + 1;
        else right = mid;
    }
    return left;
}

int findTheDistanceValue(int* arr1, int arr1Size, int* arr2, int arr2Size, int d) {
    qsort(arr2, arr2Size, sizeof(int), compare);
    int count = 0;
    
    for (int i = 0; i < arr1Size; i++) {
        int pos = binarySearch(arr2, arr2Size, arr1[i]);
        
        int isValid = 1;
        // Check left neighbor
        if (pos > 0 && abs(arr1[i] - arr2[pos - 1]) <= d) {
            isValid = 0;
        }
        // Check right neighbor
        else if (pos < arr2Size && abs(arr1[i] - arr2[pos]) <= d) {
            isValid = 0;
        }
        
        if (isValid) count++;
    }
    
    return count;
}

int main() {
    int arr1[] = {4, 5, 8};
    int arr2[] = {10, 9, 1, 8};
    int d = 2;
    printf("%d\n", findTheDistanceValue(arr1, 3, arr2, 4, d));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m log m + n log m)

O(m log m) to sort arr2, then O(n log m) for n binary searches in arr2

⚡ Linearithmic

Space Complexity

O(1)

Only constant extra space if we sort arr2 in-place

✓ Linear Space

78.0K Views

Medium Frequency

~15 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

Constraints

Visualization

Related Problems

Common Approaches

Sorting + Binary Search — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler