Який найефективніший спосіб перевірити два цілих діапазони на перекриття?

Враховуючи два цілих діапазони цілих чисел [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)

Це може легко перекрутити нормальний людський мозок, тому я знайшов візуальний підхід, який буде легше зрозуміти:

le Пояснення

Якщо два діапазони "занадто жирними", щоб вміститися в проріз, який точно відповідає сумі ширини обох, то вони перекриваються.

Для діапазонів [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!
}

Чудова відповідь від Саймона , але мені було легше думати про зворотний випадок.

Коли 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;

Якщо ви мали справу, враховуючи два діапазони [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.

Тому умова зробити 2 діапазони перекриттями:, not(y2 < x1 or x2 < y1)що еквівалентно y2 >= x1 and x2 >= y1(те саме, що приймається Саймоном відповідь).

У вас найефективніше представництво - це найменший мінімум, який потрібно перевірити, якщо ви точно не знаєте, що x1 <x2 і т. Д., То використовуйте рішення, які надали інші.

Вам, мабуть, слід зазначити, що деякі компілятори фактично оптимізують це для вас - повернувшись, як тільки будь-який із цих 4 виразів повернеться істинним. Якщо один повернеться істинним, таким буде і кінцевий результат - тому інші перевірки можна просто пропустити.

У мене справа інша. Я хочу перевірити, що два часові діапазони перекриваються. не повинно бути перекриття одиниці часу. ось перехід на реалізацію.

    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;

Якщо ви не запускаєте якісну високоефективну перевірку діапазону на мільярдах широко рознесених цілих чисел, наші версії повинні працювати аналогічно. Моя думка, це мікрооптимізація.