İki tamsayı aralığını çakışma için test etmenin en etkili yolu nedir?

İki x1: x2] ve [y1: y2] olmak üzere iki kapsayıcı tamsayı aralığı verildiğinde, x1 1 x2 ve y1 ≤ y2 olduğunda, iki aralığın çakışmasının olup olmadığını test etmenin en etkili yolu nedir?

Basit bir uygulama aşağıdaki gibidir:

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);
}

Ama bunu hesaplamanın daha etkili yolları olduğunu umuyorum.

En az operasyon açısından en etkili yöntem hangisidir?

Aralıkların çakışması ne anlama geliyor? Yani her iki aralıkta da C sayısı vardır, yani

x1 <= C <= x2

ve

y1 <= C <= y2

Şimdi, aralıkların iyi oluşturulduğunu varsayabilirsek (böylece x1 <= x2 ve y1 <= y2), test etmek yeterlidir

x1 <= y2 && y1 <= x2

İki aralık verildiğinde [x1, x2], [y1, y2]

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

Bu normal bir insan beynini kolayca çözebilir, bu yüzden anlaşılması daha kolay bir görsel yaklaşım buldum:

le Açıklama

İki aralık, her ikisinin genişliğinin toplamı olan bir yuvaya sığmayacak kadar "çok yağ" ise, üst üste binerler.

Aralık için [a1, a2]ve [b1, b2]bu:

/**
 * 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'dan büyük cevap , ama benim için tersini düşünmek daha kolaydı.

2 aralık ne zaman çakışmaz? Biri diğeri bittikten sonra başladığında örtüşmezler:

dont_overlap = x2 < y1 || x1 > y2

Şimdi örtüştüklerinde ifade etmek kolaydır:

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

Aralıkların Minimum sayısının başlangıcın Maksimum değerinden çıkarılması hile yapıyor gibi görünüyor. Sonuç sıfıra eşit veya sıfırsa, bir çakışma olur. Bu onu iyi görselleştirir:

Sorunun en kısa kodla değil en hızlı olduğunu düşünüyorum. En hızlı sürüm dallardan kaçınmak zorunda, bu yüzden böyle bir şey yazabiliriz:

basit vaka için:

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));
};

veya bu durum için:

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;

İki aralık [x1:x2]ve [y1:y2]doğal / anti-doğal düzen aralıkları ile aynı anda ilgileniyor olsaydınız :

• doğal düzen: x1 <= x2 && y1 <= y2veya
• anti-doğal sipariş: x1 >= x2 && y1 >= y2

bunu kontrol etmek için kullanmak isteyebilirsiniz:

üst üste biniyorlar <=> (y2 - x1) * (x2 - y1) >= 0

sadece dört işlem söz konusudur:

• iki çıkarma
• bir çarpma
• bir karşılaştırma

Birisi gerçek örtüşmeyi hesaplayan bir astar arıyorsa:

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

Daha az işlem, ancak birkaç değişken daha istiyorsanız:

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

Ters düşünün : 2 aralığın üst üste gelmemesini nasıl sağlarım ? Verilen [x1, x2], o [y1, y2]zaman dışarıda [x1, x2] , yani y1 < y2 < x1 or x2 < y1 < y2eşdeğer olmalıdır y2 < x1 or x2 < y1.

Bu nedenle, 2 aralığı yapma koşulu çakışır: not(y2 < x1 or x2 < y1)ki bu eşdeğerdir y2 >= x1 and x2 >= y1(Simon tarafından kabul edilen cevapla aynı).

Şimdiye kadarki en verimli temsilciliğiniz var - x1 <x2 vb. Olduğundan emin değilseniz, o zaman başkalarının sağladığı çözümleri kullanın.

Muhtemelen bazı derleyicilerin bunu sizin için gerçekten optimize edeceğine dikkat etmelisiniz - bu 4 ifadeden herhangi biri doğru olduğunda hemen geri dönerek. Eğer biri doğruysa, sonuç da sonuçlanır - böylece diğer kontroller atlanabilir.

Benim durumum farklı. iki zaman aralıkları örtüşme kontrol etmek istiyorum. birim zaman çakışması olmamalıdır. İşte Go uygulaması.

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

Test senaryoları

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")
    }

sınır karşılaştırmasında XOR deseni olduğunu görebilirsiniz

İşte benim versiyonum:

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;

Milyarlarca geniş aralıklı tamsayı üzerinde yüksek performanslı bir aralık denetleyicisi çalıştırmıyorsanız, sürümlerimiz benzer şekilde çalışmalıdır. Demek istediğim, bu mikro optimizasyon.