Mengingat koordinat dari sudut kiri atas dua kotak dan panjang sisi mereka, tentukan apakah kotak tumpang tindih. Sebuah persegi mencakup garis atas dan kiri, tetapi bukan garis bawah dan kanan. Artinya, sebuah titik (a,b)berada di dalam persegi dengan panjang sisi kyang dimulai pada (x,y)jika dan hanya jika x <= a < x+kdan y <= b < y+k. Kuadrat dengan panjang sisi 0 merosot dan tidak akan dipertimbangkan di sini, dengan demikian, kakan positif.

Seperti biasa, semua aturan standar berlaku. Input dan output mungkin dalam bentuk apa pun yang nyaman, asalkan itu dapat dibaca manusia dan tidak ada perhitungan. Pastikan untuk menentukan format input apa yang Anda gunakan. Kode Anda harus mengambil enam angka dan menghasilkan kebenaran jika kotak tumpang tindih dan palsu sebaliknya.

Uji Kasus

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

Semua input akan berupa bilangan bulat non-negatif. Yang mengatakan, saya berharap bahwa banyak atau sebagian besar solusi juga akan mampu menangani hal negatif dan mengapung.

Python, 33 byte

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

Python mendukung rantai ketidaksetaraan bahkan ketika mereka menunjuk ke arah yang berlawanan.

Interval x-koordinat [x,x+k)dan [X,X+K)tumpang tindih selama tidak ada yang sepenuhnya ke kanan yang lain, yang berarti bahwa setiap titik akhir kiri interval adalah kiri dari titik akhir kanan interval lainnya.

x<X+K
X<x+k

Itu bisa digabungkan menjadi ketimpangan bersama -K<X-x<k. Menulis hal yang sama untuk koordinat-y dan menyambungkannya pada -Kmemberikan ekspresi

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

MATL, 14 11 10 5 4 byte

tP->

Solusi ini menerima input dalam bentuk dua array:

1. Matriks 2 x 2 yang berisi koordinat sudut [x1, y1; x2, y2]
2. Array 2 x 1 berisi dimensi persegi [k2; k1]

Cobalah secara Online

Versi yang sedikit dimodifikasi untuk menjalankan semua kasus uji

Penjelasan

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

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

Membuat fungsi anonim yang dapat dievaluasi sebagai ans(a,b). Menerima dua input dari format berikut:

1. 2 x 2 matriks yang mengandung sudut masing-masing persegi sebagai berturut-turut: [x1, y1; x2, y2].
2. 2 x 1 array berisi ukuran dua kotak: [k2; k1]

Semua test case di sini .

Penjelasan

Berikut ini adalah solusi un-golfed yang dikomentari

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

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

Jika d - a ≥ c maka kuadrat kedua di sebelah kanan yang pertama. Demikian pula kondisi lain memeriksa bahwa itu tidak ke kiri, di bawah atau di atas.

Jelly , 8 byte

Ṫṗ2+µ€f/

Input adalah daftar bersarang [[x1, y1, k1], [x2, y2, k2]] , output adalah daftar semua koordinat titik yang bertambah dengan koordinat bilangan bulat yang umum untuk kedua kotak (salah jika kosong, benar jika kosong, jujur ​​jika tidak ).

Cobalah online! atau verifikasi semua kasus uji .

Bagaimana itu bekerja

Ṫṗ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 byte

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

Java, 78 byte

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

Oktaf, 17 byte

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

Logika yang sama dengan jawaban MATLAB saya di atas, kecuali bahwa Oktaf mendukung penyiaran dimensi secara otomatis sehingga kami dapat menggantinya [b,b]dengan mudah b.

Semua test case di sini

SmileBASIC, 76 57 byte

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

Buat sprite dengan ukuran / posisi kotak pertama, lalu periksa apakah bertabrakan dengan kotak kedua.

x86-64 Kode mesin, Windows 22 byte

Tanda tangan C ++:

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

Mengembalikan 0 jika kotak tidak tumpang tindih dan -1 (0xFFFFFFFF) sebaliknya. Input adalah vektor 2 bilangan bulat 64-bit untuk x, y dan k ( _mm_set_epi64x(x1, x2)dll.).

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 byte

Â-›˜P

Pelabuhan @Suever 's jawaban MATL , dengan konversi tambahan untuk hasil truthy / falsey. Format input karena itu juga sama:
Input pertama sebagai [[x1,y1],[x2,y2]]dan input kedua sebagai [k2,k1].

Cobalah secara online atau verifikasi semua kasus uji .

Penjelasan:

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