중복에 대해 두 정수 범위를 테스트하는 가장 효율적인 방법은 무엇입니까?

x1 ≤ x2 및 y1 ≤ y2 인 두 개의 포괄적 인 정수 범위 [x1 : x2] 및 [y1 : y2]가 주어지면 두 범위의 겹침이 있는지 테스트하는 가장 효율적인 방법은 무엇입니까?

간단한 구현은 다음과 같습니다.

bool testOverlap(int x1, int x2, int y1, int y2) {
  return (x1 >= y1 && x1 <= y2) ||
         (x2 >= y1 && x2 <= y2) ||
         (y1 >= x1 && y1 <= x2) ||
         (y2 >= x1 && y2 <= x2);
}

그러나 이것을 계산하는보다 효율적인 방법이있을 것으로 기대합니다.

가장 적은 작업 측면에서 가장 효율적인 방법은 무엇입니까?

범위가 겹치는 것은 무엇을 의미합니까? 즉, 두 범위에있는 숫자 C가 있음을 의미합니다.

x1 <= C <= x2

과

y1 <= C <= y2

이제 범위가 잘 구성되어 있다고 가정하면 (x1 <= x2 및 y1 <= y2) 테스트하기에 충분합니다.

x1 <= y2 && y1 <= x2

두 가지 범위 [x1, x2], [y1, y2]

def is_overlapping(x1,x2,y1,y2):
    return max(x1,y1) <= min(x2,y2)

이것은 정상적인 인간의 뇌를 쉽게 뒤틀 수 있기 때문에 이해하기 쉬운 시각적 접근 방식을 찾았습니다.

르 설명

두 범위가 "너무 뚱뚱해" 두 슬롯의 너비를 모두 합한 슬롯에 맞으면 겹쳐집니다.

범위의 경우 다음 [a1, a2]과 [b1, b2]같습니다.

/**
 * we are testing for:
 *     max point - min point < w1 + w2    
 **/
if max(a2, b2) - min(a1, b1) < (a2 - a1) + (b2 - b1) {
  // too fat -- they overlap!
}

Simon의 큰 대답 이지만 저에게는 반대 사례를 생각하는 것이 더 쉬웠습니다.

두 범위가 겹치지 않는 경우는 언제입니까? 그것들 중 하나가 다른 하나가 끝난 후에 시작될 때 겹치지 않습니다.

dont_overlap = x2 < y1 || x1 > y2

이제 겹칠 때 쉽게 표현할 수 있습니다.

overlap = !dont_overlap = !(x2 < y1 || x1 > y2) = (x2 >= y1 && x1 <= y2)

시작의 최대 값에서 범위의 끝의 최소값을 빼면 트릭을 수행하는 것 같습니다. 결과가 0보다 작거나 같으면 겹칩니다. 이것은 그것을 잘 시각화합니다 :

질문은 가장 짧은 코드가 아니라 가장 빠른 코드라고 생각합니다. 가장 빠른 버전은 가지를 피해야하므로 다음과 같이 작성할 수 있습니다.

간단한 경우 :

static inline bool check_ov1(int x1, int x2, int y1, int y2){
    // insetead of x1 < y2 && y1 < x2
    return (bool)(((unsigned int)((y1-x2)&(x1-y2))) >> (sizeof(int)*8-1));
};

또는이 경우 :

static inline bool check_ov2(int x1, int x2, int y1, int y2){
    // insetead of x1 <= y2 && y1 <= x2
    return (bool)((((unsigned int)((x2-y1)|(y2-x1))) >> (sizeof(int)*8-1))^1);
};

return x2 >= y1 && x1 <= y2;

두 가지 범위 [x1:x2]와 [y1:y2]자연 / 반 자연적 순서 범위를 동시에 다루는 경우 :

• 자연 질서 : x1 <= x2 && y1 <= y2또는
• 비 자연적 질서 : x1 >= x2 && y1 >= y2

다음을 사용하여 확인할 수 있습니다.

그들은 겹친다 <=> (y2 - x1) * (x2 - y1) >= 0

경우에만 네 개의 작업이 참여하고 있습니다 :

• 두 빼기
• 한 번의 곱셈
• 하나의 비교

누군가가 실제 중첩을 계산하는 하나의 라이너를 찾고 있다면 :

int overlap = ( x2 > y1 || y2 < x1 ) ? 0 : (y2 >= y1 && x2 <= y1 ? y1 : y2) - ( x2 <= x1 && y2 >= x1 ? x1 : x2) + 1; //max 11 operations

몇 가지 더 적은 작업을 원하지만 몇 가지 더 많은 변수를 원할 경우 :

bool b1 = x2 <= y1;
bool b2 = y2 >= x1;
int overlap = ( !b1 || !b2 ) ? 0 : (y2 >= y1 && b1 ? y1 : y2) - ( x2 <= x1 && b2 ? x1 : x2) + 1; // max 9 operations

반대의 방법으로 생각하십시오 : 2 개의 범위를 겹치지 않게 하는 방법 ? 을 감안할 때 [x1, x2], 다음 [y1, y2]해야 외부 [x1, x2] , 즉, y1 < y2 < x1 or x2 < y1 < y2에 해당한다 y2 < x1 or x2 < y1.

따라서 두 범위를 겹치는 조건은 겹치게됩니다. not(y2 < x1 or x2 < y1)이는 y2 >= x1 and x2 >= y1(Simon의 허용 된 대답과 동일)입니다.

당신은 이미 가장 효율적인 표현을 가지고 있습니다-x1 <x2 등을 확실히 알지 못한다면 다른 사람들이 제공 한 솔루션을 사용하지 않는 한 확인해야 할 최소값입니다.

아마도 4 개의 표현식 중 하나라도 true를 반환하자마자 반환함으로써 일부 컴파일러는 실제로이를 최적화 할 것입니다. 하나가 true를 반환하면 최종 결과도 마찬가지이므로 다른 검사는 건너 뛸 수 있습니다.

제 사건은 다릅니다. 두 시간 범위가 겹치는 지 확인하고 싶습니다. 단위 시간 중복이 없어야합니다. 다음은 Go 구현입니다.

    func CheckRange(as, ae, bs, be int) bool {
    return (as >= be) != (ae > bs)
    }

테스트 사례

if CheckRange(2, 8, 2, 4) != true {
        t.Error("Expected 2,8,2,4 to equal TRUE")
    }

    if CheckRange(2, 8, 2, 4) != true {
        t.Error("Expected 2,8,2,4 to equal TRUE")
    }

    if CheckRange(2, 8, 6, 9) != true {
        t.Error("Expected 2,8,6,9 to equal TRUE")
    }

    if CheckRange(2, 8, 8, 9) != false {
        t.Error("Expected 2,8,8,9 to equal FALSE")
    }

    if CheckRange(2, 8, 4, 6) != true {
        t.Error("Expected 2,8,4,6 to equal TRUE")
    }

    if CheckRange(2, 8, 1, 9) != true {
        t.Error("Expected 2,8,1,9 to equal TRUE")
    }

    if CheckRange(4, 8, 1, 3) != false {
        t.Error("Expected 4,8,1,3 to equal FALSE")
    }

    if CheckRange(4, 8, 1, 4) != false {
        t.Error("Expected 4,8,1,4 to equal FALSE")
    }

    if CheckRange(2, 5, 6, 9) != false {
        t.Error("Expected 2,5,6,9 to equal FALSE")
    }

    if CheckRange(2, 5, 5, 9) != false {
        t.Error("Expected 2,5,5,9 to equal FALSE")
    }

경계 비교에 XOR 패턴이 있음을 알 수 있습니다

내 버전은 다음과 같습니다.

int xmin = min(x1,x2)
  , xmax = max(x1,x2)
  , ymin = min(y1,y2)
  , ymax = max(y1,y2);

for (int i = xmin; i < xmax; ++i)
    if (ymin <= i && i <= ymax)
        return true;

return false;

수십억 개의 넓은 간격의 정수에 대해 고성능 범위 검사기를 실행하지 않는 한, 우리의 버전도 비슷하게 작동해야합니다. 내 요점은 이것이 미세 최적화입니다.