2つの整数の範囲の重複をテストする最も効率的な方法は何ですか？

2つの包括的な整数範囲[x1：x2]と[y1：y2]が与えられた場合、x1≤x2とy1≤y2の場合、2つの範囲が重複しているかどうかをテストする最も効率的な方法は何ですか？

簡単な実装は次のとおりです。

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

2つの範囲[x1、x2]、[y1、y2]

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

これは通常の人間の脳を簡単に歪める可能性があるため、視覚的なアプローチの方が理解しやすいことがわかりました。

le説明

2つの範囲が「太すぎる」ため、両方の幅の合計であるスロットに正確に収まらない場合、範囲は重複します。

範囲の場合[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からの素晴らしい回答ですが、私にとっては、逆のケースについて考える方が簡単でした。

2つの範囲が重ならないのはいつですか？片方がもう片方が終わった後にそれらが始まるとき、それらは重なりません：

dont_overlap = x2 < y1 || x1 > y2

これらが重なる場合は簡単に表現できます。

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

最初の最大値から範囲の最小値を減算することは、トリックを行うようです。結果がゼロ以下の場合、重複があります。これはそれをうまく視覚化します：

問題は、最短のコードではなく、最速のコードに関するものだったと思います。最速のバージョンはブランチを避けなければならないので、次のようなものを書くことができます：

単純な場合：

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;

あなたが扱っていた場合、2つの範囲[x1:x2]と[y1:y2]、自然/反自然順序範囲が同時に与えられた場合：

• 自然順：x1 <= x2 && y1 <= y2または
• 反自然な秩序： x1 >= x2 && y1 >= y2

次に、これを使用して確認することができます。

それらは重複しています<=> (y2 - x1) * (x2 - y1) >= 0

4つの操作のみが関係する場合：

• 2つの減算
• 1つの乗算
• 1つの比較

実際のオーバーラップを計算するワンライナーを誰かが探している場合：

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

数少ない操作が必要だが、変数が2つ多い場合：

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 < y2y2 < x1 or x2 < y1

したがって、2つの範囲をオーバーラップさせるための条件：はnot(y2 < x1 or x2 < y1)、y2 >= x1 and x2 >= y1（Simonが承認した回答と同じ）と同等です。

あなたはすでに最も効率的な表現を持っています-x1 <x2などであることを確実に知らない限りチェックする必要のある最低限のものであり、他の人が提供したソリューションを使用してください。

これらの4つの式のいずれかがtrueを返すとすぐに戻ることによって、一部のコンパイラーが実際にこれを最適化することに注意する必要があります。1つがtrueを返す場合、最終結果もそうなります-他のチェックはスキップすることができます。

私の場合は違います。2つの時間範囲が重複していることを確認します。単位時間の重複があってはなりません。これが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;

何十億もの間隔の広い整数で高性能のレンジチェッカーを実行しているのでない限り、私たちのバージョンも同様に動作するはずです。私のポイントは、これはマイクロ最適化です。