Враховуючи координати лівих верхніх кутів двох квадратів та їх бічну довжину, визначте, чи перекриваються квадрати. Квадрат включає верхню та ліву лінії, але не нижню та праву. Тобто, точка (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

Усі входи будуть невід’ємними цілими числами. Зважаючи на це, я сподіваюся, що багато чи більшість рішень також зможуть впоратися з негативами та поплавками.

Пітон, 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 х 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 - a ≥ c, то другий квадрат знаходиться праворуч від першого. Аналогічно, інші умови перевіряють, чи не зліва, внизу або вгорі.

Желе , 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]їх просто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). Вхідні дані - це вектори 2-х 64-бітних цілих чисел для x, y та k ( _mm_set_epi64x(x1, x2)тощо).

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

Порт відповіді MATL @Suever , з додатковим перетворенням на результат truthy / falsey. Формат вводу також є однаковим:
Перший вхід як [[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)