Dadas las coordenadas de las esquinas superiores izquierdas de dos cuadrados y sus longitudes laterales, determine si los cuadrados se superponen. Un cuadrado incluye las líneas superior e izquierda, pero no las líneas inferior y derecha. Es decir, un punto (a,b)está dentro de un cuadrado con longitud lateral kque comienza en (x,y)si y solo si x <= a < x+ky y <= b < y+k. Un cuadrado con longitud lateral 0 es degenerado y no se considerará aquí, por lo tanto, kserá positivo.

Como de costumbre, se aplican todas las reglas estándar. La entrada y la salida pueden estar en cualquier forma que sea conveniente, siempre que sea legible por humanos y no haya una precomputación. Asegúrese de especificar qué formato de entrada usa. Su código debe tomar seis números y generar una verdad si los cuadrados se superponen y falsa de lo contrario.

Casos de prueba

x1 y1 k1  x2 y2 k2  overlap?
 1  1  1   0  1  1  false
 0  0  3   1  1  1  true
 1  1  1   0  0  3  true
 0  0  3   2  1  2  true
 0  0  2   1  1  2  true
 1  1  2   0  0  2  true
 0  1  2   1  0  2  true
 1  0  2   0  1  2  true
 2  0  2   0  2  2  false
 1  0  3   0  1  1  false
 0  2  3   0  0  2  false

Todas las entradas serán enteros no negativos. Dicho esto, espero que muchas o la mayoría de las soluciones también puedan manejar negativos y flotadores.

Python, 33 bytes

lambda x,y,k,X,Y,K:k>X-x>-K<Y-y<k

Python admite cadenas de desigualdades incluso cuando apuntan en direcciones opuestas.

La coordenada x intervalos [x,x+k)y [X,X+K)se superponen, siempre y cuando ninguno de los dos es totalmente a la derecha de la otra, lo que significa que extremo izquierdo de cada intervalo se deja de punto final derecho del otro intervalo.

x<X+K
X<x+k

El puede combinarse en una desigualdad conjunta -K<X-x<k. Escribir lo mismo para las coordenadas y y empalmarlas -Kda la expresión

k>X-x>-K<Y-y<k

MATL, 14 11 10 5 4 bytes

tP->

Esta solución acepta entradas en forma de dos matrices:

1. Una matriz de 2 x 2 que contiene las coordenadas de las esquinas. [x1, y1; x2, y2]
2. Una matriz de 2 x 1 que contiene las dimensiones cuadradas [k2; k1]

Pruébalo en línea

Versión ligeramente modificada para ejecutar todos los casos de prueba

Explicación

        % Implicitly grab the first input
t       % Duplicate the input
P       % Flip along the first dimension (columns)
-       % Subtract the two to yield [x1-x2, y1-y2; x2-x1, y2-y1]
        % Implicitly grab the second input
>       % Compare with [k2, k1] (automatically broadcasts)
        % Implicitly display the truthy/falsey result

MATLAB, 36 21 bytes

@(a,b)a-flip(a)<[b,b]

Crea una función anónima que se puede evaluar como ans(a,b). Acepta dos entradas del siguiente formato:

1. 2 x 2 matriz que contiene la esquina de cada cuadrado como una fila: [x1, y1; x2, y2].
2. Conjunto de 2 x 1 que contiene el tamaño de los dos cuadrados: [k2; k1]

Todos los casos de prueba aquí .

Explicación

Aquí hay una solución comentada sin golf

%// Example input
a = [1 1;
     0 1];

b = [1; 1];

%// Flip a along the first dimension and subtract from a to yield:
%// 
%// [x1-x2   y1-y2]
%// [x2-x1   y2-y1]
d = a - flip(a);

%// Compare this matrix element-wise with two horizontally concatenated copies 
%// of the second input [k2; k1]
result = d < [b,b];

%// Truthy values have all ones in the result and falsey values have at
%// least one 0 in the result.

JavaScript (ES6), 38 bytes

(a,b,c,d,e,f)=>d-a<c&a-d<f&e-b<c&b-e<f

Si d - a ≥ c, entonces el segundo cuadrado está a la derecha del primero. Del mismo modo, las otras condiciones verifican que no esté a la izquierda, debajo o arriba.

Jalea , 8 bytes

Ṫṗ2+µ€f/

La entrada es la lista anidada [[x1, y1, k1], [x2, y2, k2]] , la salida es la lista de todas las coordenadas incrementales de puntos con coordenadas enteras que son comunes a ambos cuadrados (falso si está vacío, verdad si no )

Pruébalo en línea! o verificar todos los casos de prueba .

Cómo funciona

Ṫṗ2+µ€f/  Main link. Argument: [[x1, y1, k1], [x2, y2, k2]]

    µ     Combine the chain to the left into a link.
     €    Apply it to each list [xi, yi, ki].
Ṫ           Tail; pop and yield ki.
 ṗ2         Second Cartesian power; yield the list of all pairs [a, b] such that
            1 ≤ a ≤ ki and 1 ≤ b ≤ ki.
   +        Add [xi, yi] to each pair, yielding the list of all pairs [c, d] such
            that xi + 1 ≤ c ≤ xi + ki and yi + 1 ≤ d ≤ yi + ki.
      f/  Reduce by filter, intersecting the resulting lists of pairs.

TI Basic, 36 bytes

Prompt X,Y,K,Z,θ,L:Z-X<K and X-Z<L and θ-Y<K and Y-θ<L

Java, 78 bytes

Object o(int a,int b,int c,int d,int e,int f){return d-a<c&a-d<f&e-b<c&b-e<f;}

Octava, 17 bytes

@(a,b)a-flip(a)<b

La misma lógica que mi respuesta MATLAB anterior, excepto que Octave admite la transmisión automática de dimensiones para que podamos reemplazarlas [b,b]simplemente b.

Todos los casos de prueba aquí

SmileBASIC, 76 57 bytes

INPUT X,Y,W,S,T,U
SPSET.,X,Y,W,W
SPCOL.?!SPHITRC(S,T,U,U)

Crea un sprite con el tamaño / posición del primer cuadrado, luego comprueba si colisiona con el segundo cuadrado.

x86-64 Código de máquina, Windows 22 bytes

Firma C ++:

extern "C" uint32_t __vectorcall squareOverlap(__m128i x, __m128i y, __m128i k);

Devuelve 0 si los cuadrados no se superponen y -1 (0xFFFFFFFF) de lo contrario. Las entradas son vectores de 2 enteros de 64 bits para x, y y k ( _mm_set_epi64x(x1, x2)etc.).

squareOverlap@@48 proc
66 0F FB C8          psubq       xmm1,xmm0
0F 16 D2             movlhps     xmm2,xmm2
66 0F 38 37 D1       pcmpgtq     xmm2,xmm1
0F 12 CA             movhlps     xmm1,xmm2
0F 54 CA             andps       xmm1,xmm2
66 0F 7E C8          movd        eax,xmm1 
C3                   ret  
squareOverlap@@48 endp

05AB1E , 5 bytes

Â-›˜P

Puerto de @Suever respuesta MAT 's , con la conversión adicional a consecuencia Truthy / Falsey-. Por lo tanto, el formato de entrada también es el mismo:
primera entrada como [[x1,y1],[x2,y2]]y segunda entrada como [k2,k1].

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

       # Bifurcate (short for Duplicate & Reverse copy) the (implicit) input-matrix
 -      # Subtract each value (vectorized) from the input-matrix we duplicated
  ›     # Check for both values (vectorized) if it's larger than the (implicit) input-list
        # (We now have the same result as the MATL answer. In MATL a matrix/list consisting
        #  of only 1s is truthy. In 05AB1E this isn't the case however, so:)
    ˜   # Flatten the matrix to a single list
     P  # And take the product to check if all are truthy
        # (after which the result is output implicitly)