给定两个正方形的左上角的坐标及其边长，确定正方形是否重叠。正方形包括顶部和左侧线条，但不包括底部和右侧线条。也就是说，一个点(a,b)位于边长为正方形且k位于(x,y)且仅当x <= a < x+k和时的正方形内y <= b < y+k。边长为0的正方形是简并的，此处将不考虑，因此k将为正。

与往常一样，所有标准规则均适用。输入和输出可以采用任何方便的形式，只要它是人类可读的并且没有预先计算即可。确保指定使用的输入格式。您的代码应采用六个数字，并且如果正方形重叠则输出真实，否则输出虚假。

测试用例

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

所有输入均为非负整数。就是说，我希望许多解决方案或大多数解决方案也能够处理负值和浮动。

Python，33个字节

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

Python支持不等式链，即使它们指向相反的方向。

x坐标间隔[x,x+k)和[X,X+K)重叠，只要两个坐标都不完全在另一个坐标的右边，这意味着每个间隔的左端点在另一个坐标的右端点的左边。

x<X+K
X<x+k

可以合并为一个联合不等式-K<X-x<k。写作同样为y坐标和拼接他们在-K给人的表达

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

MATL，14 11 10 5 4字节

tP->

此解决方案接受两个数组形式的输入：

1. 一个2 x 2矩阵，包含角的坐标 [x1, y1; x2, y2]
2. 包含正方形尺寸的2 x 1数组 [k2; k1]

在线尝试

略作修改的版本可以运行所有测试用例

说明

        % 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字节

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

创建一个可以评估为的匿名函数ans(a,b)。接受以下格式的两个输入：

1. 2×2矩阵包含每个正方形为行的角：[x1, y1; x2, y2]。
2. 2 x 1数组，包含两个正方形的大小： [k2; k1]

所有测试用例都在这里。

说明

这是未评论的解决方案

%// 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个字节

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

如果d - 一个 ≥ ç然后第二方是所述第一的右侧。同样，其他条件也会检查它是否位于左侧，下方或上方。

果冻，8 字节

Ṫṗ2+µ€f/

输入是嵌套列表[[x1，y1，k1]，[x2，y2，k2]]，输出是两个正方形都具有整数坐标的点的所有增量坐标的列表（如果为空则为假，否则为真） ）。

在线尝试！或验证所有测试用例。

这个怎么运作

Ṫṗ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字节

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

Java，78个字节

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

八度，17字节

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

与我上面的MATLAB回答相同的逻辑，除了Octave支持尺寸的自动广播，因此我们可以[b,b]用simple 代替b。

这里的所有测试用例

SmileBASIC，76 57字节

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

使用第一个正方形的大小/位置创建一个精灵，然后检查它是否与第二个正方形碰撞。

x86-64机器代码，Windows 22字节

C ++签名：

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

如果正方形不重叠，则返回0，否则返回-1（0xFFFFFFFF）。输入是x，y和k（_mm_set_epi64x(x1, x2)等）的2个64位整数的向量。

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 个字节

Â-›˜P

@Suever的MATL答案的端口，并附加转换为真/假结果。因此，输入格式也相同：
第一个输入为[[x1,y1],[x2,y2]]，第二个输入为[k2,k1]。

在线尝试或验证所有测试用例。

说明：

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