¿Cuál es la forma más eficiente de probar la superposición de dos rangos enteros?

Dados dos rangos enteros inclusivos [x1: x2] y [y1: y2], donde x1 ≤ x2 e y1 ≤ y2, ¿cuál es la forma más eficiente de probar si hay una superposición de los dos rangos?

Una implementación simple es la siguiente:

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

Pero espero que haya formas más eficientes de calcular esto.

Qué método sería el más eficiente en términos de la menor cantidad de operaciones.

¿Qué significa que los rangos se superpongan? Significa que existe algún número C que está en ambos rangos, es decir

x1 <= C <= x2

y

y1 <= C <= y2

Ahora, si se nos permite suponer que los rangos están bien formados (de modo que x1 <= x2 e y1 <= y2), entonces es suficiente probar

x1 <= y2 && y1 <= x2

Dados dos rangos [x1, x2], [y1, y2]

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

Esto puede deformar fácilmente un cerebro humano normal, por lo que he encontrado un enfoque visual que es más fácil de entender:

le Explicación

Si dos rangos son "demasiado gruesos" para caber en una ranura que es exactamente la suma del ancho de ambos, entonces se superponen.

Para rangos [a1, a2]y [b1, b2]esto sería:

/**
 * 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!
}

Gran respuesta de Simon , pero para mí fue más fácil pensar en el caso inverso.

¿Cuándo no se superponen 2 rangos? No se superponen cuando uno de ellos comienza después de que el otro termina:

dont_overlap = x2 < y1 || x1 > y2

Ahora es fácil expresar cuándo se superponen:

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

Restar el mínimo de los extremos de los rangos del máximo del principio parece ser el truco. Si el resultado es menor o igual a cero, tenemos una superposición. Esto lo visualiza bien:

Supongo que la pregunta era sobre el código más rápido, no el más corto. La versión más rápida tiene que evitar las ramas, por lo que podemos escribir algo como esto:

por simple caso:

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

o, para este caso:

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;

Si estaba lidiando, dados dos rangos [x1:x2]y rangos de orden [y1:y2]natural / antinatural al mismo tiempo donde:

• orden natural: x1 <= x2 && y1 <= y2o
• orden antinatural: x1 >= x2 && y1 >= y2

entonces es posible que desee usar esto para verificar:

se superponen <=> (y2 - x1) * (x2 - y1) >= 0

donde solo participan cuatro operaciones:

• dos restas
• una multiplicación
• una comparación

Si alguien está buscando una línea que calcule la superposición real:

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

Si desea un par de operaciones menos, pero un par de variables más:

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

Piense de manera inversa : ¿cómo hacer que los 2 rangos no se superpongan ? Dado [x1, x2], entonces [y1, y2]debe estar afuera [x1, x2] , es decir, y1 < y2 < x1 or x2 < y1 < y2que es equivalente ay2 < x1 or x2 < y1 .

Por lo tanto, la condición para hacer que los 2 rangos se superpongan: not(y2 < x1 or x2 < y1)es equivalente a y2 >= x1 and x2 >= y1(lo mismo con la respuesta aceptada por Simon).

Ya tiene la representación más eficiente: es el mínimo necesario que debe verificarse a menos que sepa con certeza que x1 <x2, etc., luego use las soluciones que otros han proporcionado.

Probablemente debería tener en cuenta que algunos compiladores realmente optimizarán esto para usted, al regresar tan pronto como cualquiera de esas 4 expresiones devuelva verdadero. Si uno devuelve verdadero, también lo hará el resultado final, por lo que las otras verificaciones solo se pueden omitir.

Mi caso es diferente. Quiero comprobar la superposición de dos rangos de tiempo. no debe haber una superposición de unidad de tiempo. aquí está la implementación de Go.

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

Casos de prueba

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

puedes ver que hay un patrón XOR en la comparación de límites

Aquí está mi versión:

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;

A menos que esté ejecutando un comprobador de rango de alto rendimiento en miles de millones de enteros ampliamente espaciados, nuestras versiones deberían funcionar de manera similar. Mi punto es que esto es micro-optimización.