2つの正方形の左上隅の座標とその辺の長さを考慮して、正方形が重なるかどうかを判断します。正方形には上下の線が含まれますが、下と右の線は含まれません。つまり、点(a,b)はk、(x,y)ifおよびの場合にのみ辺の長さを持つ正方形の内側にx <= a < x+kありy <= b < y+kます。辺の長さが0の正方形は縮退しているため、ここでは考慮されないため、k正になります。

通常どおり、すべての標準ルールが適用されます。入力と出力は、人間が読める形式であり、事前計算がない限り、どんな形式でも便利です。使用する入力形式を必ず指定してください。コードは6つの数字を取り、正方形が重なる場合は真実を出力し、そうでない場合は偽を出力する必要があります。

テストケース

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+k)、x座標の間隔と[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->

このソリューションは、2つの配列の形式で入力を受け入れます。

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)。次の形式の2つの入力を受け入れます。

1. 行として各正方形のコーナーを含む2 x 2マトリックス：[x1, y1; x2, y2]。
2. 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 - ≥ C、第2の正方形は、第一の右側にあります。同様に、他の条件は、左、下、上ではないことを確認します。

ゼリー、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ベーシック、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]、単にに置き換えることができbます。

すべてのテストケースはこちら

SmileBASIC、76 57バイト

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

最初の正方形のサイズ/位置でスプライトを作成し、2番目の正方形と衝突するかどうかを確認します。

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回答のポート、真実/偽の結果への追加変換。したがって、input-formatも同じです
。1 [[x1,y1],[x2,y2]]番目の入力はで、2番目の入力は[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)