Dadas as coordenadas dos cantos superiores esquerdo de dois quadrados e seus comprimentos laterais, determine se os quadrados se sobrepõem. Um quadrado inclui as linhas superior e esquerda, mas não as linhas inferior e direita. Ou seja, um ponto (a,b)está dentro de um quadrado com comprimento lateral kque começa em (x,y)se e somente se x <= a < x+ke y <= b < y+k. Um quadrado com comprimento lateral 0 é degenerado e não será considerado aqui, portanto, kserá positivo.

Como sempre, todas as regras padrão se aplicam. A entrada e a saída podem estar em qualquer forma que seja conveniente, desde que seja legível por humanos e não haja pré-computação. Certifique-se de especificar qual formato de entrada você usa. Seu código deve receber seis números e produzir verdade se os quadrados se sobrepuserem e falsificarem o contrário.

Casos de teste

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 as entradas serão números inteiros não negativos. Dito isto, espero que muitas ou a maioria das soluções também sejam capazes de lidar com negativos e flutuadores.

Python, 33 bytes

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

O Python suporta cadeias de desigualdades, mesmo quando apontam direções opostas.

A coordenada x intervalos [x,x+k)e [X,X+K)se sobrepõem, desde que nenhum deles é completamente para a direita do outro, o que significa que endpoint esquerda de cada intervalo é deixado de endpoint o direito da outra intervalo.

x<X+K
X<x+k

O pode ser combinado em uma desigualdade conjunta -K<X-x<k. Escrever o mesmo para as coordenadas y e uni-las em -Kdá a expressão

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

MATL, 14 11 10 5 4 bytes

tP->

Esta solução aceita entrada na forma de duas matrizes:

1. Uma matriz 2 x 2 que contém as coordenadas dos cantos [x1, y1; x2, y2]
2. Uma matriz 2 x 1 contendo as dimensões quadradas [k2; k1]

Experimente Online

Versão ligeiramente modificada para executar todos os casos de teste

Explicação

        % 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]

Cria uma função anônima que pode ser avaliada como ans(a,b). Aceita duas entradas do seguinte formato:

1. 2 x 2 de matriz contendo o canto de cada quadrado como uma linha: [x1, y1; x2, y2].
2. Matriz 2 x 1 contendo o tamanho dos dois quadrados: [k2; k1]

Todos os casos de teste aqui .

Explicação

Aqui está uma solução não-golfe comentada

%// 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

Se d - a ≥ c , o segundo quadrado fica à direita do primeiro. Da mesma forma, as outras condições verificam se não está à esquerda, abaixo ou acima.

Geléia , 8 bytes

Ṫṗ2+µ€f/

Input é a lista aninhada [[x1, y1, k1], [x2, y2, k2]] , output é a lista de todas as coordenadas incrementadas de pontos com coordenadas inteiras que são comuns a ambos os quadrados (falso se estiver vazio, verdadeiro se não estiver) )

Experimente online! ou verifique todos os casos de teste .

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

Oitava, 17 bytes

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

A mesma lógica da minha resposta do MATLAB acima, exceto que o Octave suporta a transmissão automática de dimensões para que possamos substituí [b,b]-lo simplesmente b.

Todos os casos de teste aqui

SmileBASIC, 76 57 bytes

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

Cria um sprite com o tamanho / posição do primeiro quadrado e verifica se ele colide com o segundo quadrado.

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

Assinatura C ++:

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

Retorna 0 se os quadrados não se sobrepõem e -1 (0xFFFFFFFF), caso contrário. As entradas são vetores de 2 números inteiros de 64 bits para x, yek ( _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

Porto de @Suever resposta MATL 's , com a conversão adicional a um resultado truthy / Falsey. O formato de entrada também é o mesmo:
Primeira entrada como [[x1,y1],[x2,y2]]e segunda entrada como [k2,k1].

Experimente online ou verifique todos os casos de teste .

Explicação:

       # 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)