Biorąc pod uwagę współrzędne lewego górnego rogu dwóch kwadratów i ich długości boków, określ, czy kwadraty nachodzą na siebie. Kwadrat zawiera górną i lewą linię, ale nie dolną i prawą linię. Oznacza to, że punkt (a,b)znajduje się wewnątrz kwadratu o długości boku, kktóra zaczyna się (x,y)wtedy i tylko wtedy x <= a < x+ki wtedy y <= b < y+k. Kwadrat o długości boku 0 jest zdegenerowany i nie będzie tutaj brany pod uwagę, więc kbędzie dodatni.

Jak zwykle obowiązują wszystkie standardowe zasady. Dane wejściowe i wyjściowe mogą być w dowolnej dogodnej formie, o ile są czytelne dla człowieka i nie ma wstępnego obliczenia. Pamiętaj, aby określić używany format wejściowy. Twój kod powinien przyjmować sześć liczb i wyświetlać zgodnie z prawdą, jeśli kwadraty nachodzą na siebie, a fałsz w przeciwnym razie.

Przypadki testowe

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

Wszystkie dane wejściowe będą liczbami całkowitymi nieujemnymi. To powiedziawszy, oczekuję, że wiele lub większość rozwiązań będzie w stanie poradzić sobie z negatywami i zmiennymi.

Python, 33 bajty

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

Python obsługuje łańcuch nierówności, nawet gdy wskazują przeciwne kierunki.

Współrzędna x interwały [x,x+k)i [X,X+K)nakładają się na siebie, o ile nie jest w pełni jeden na prawo od drugiej, co oznacza, że lewy punkt końcowy każdego przedziału jest na lewo od prawego punktu końcowego drugiego interwału jest.

x<X+K
X<x+k

Można je połączyć we wspólną nierówność -K<X-x<k. Pisanie tego samego dla współrzędnych y i łączenie ich w -Kdaje wyrażenie

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

MATL, 14 11 10 5 4 bajtów

tP->

To rozwiązanie przyjmuje dane wejściowe w postaci dwóch tablic:

1. Matryca 2 x 2, która zawiera współrzędne narożników [x1, y1; x2, y2]
2. Tablica 2 x 1 zawierająca wymiary kwadratu [k2; k1]

Wypróbuj online

Nieznacznie zmodyfikowana wersja do uruchamiania wszystkich przypadków testowych

Wyjaśnienie

        % 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 bajtów

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

Tworzy anonimową funkcję, którą można ocenić jako ans(a,b). Akceptuje dwa wejścia o następującym formacie:

1. 2 x 2 matrycę zawierającą rogu każdego kwadratu jako wiersz: [x1, y1; x2, y2].
2. Tablica 2 x 1 zawierająca rozmiar dwóch kwadratów: [k2; k1]

Wszystkie przypadki testowe tutaj .

Wyjaśnienie

Oto skomentowane rozwiązanie bez gry w golfa

%// 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 bajtów

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

Jeśli d - a ≥ c, to drugi kwadrat jest po prawej stronie pierwszego. Podobnie pozostałe warunki sprawdzają, czy nie jest po lewej, poniżej lub powyżej.

Galaretka , 8 bajtów

Ṫṗ2+µ€f/

Dane wejściowe to lista zagnieżdżona [[x1, y1, k1], [x2, y2, k2]] , dane wyjściowe to lista wszystkich inkrementowanych współrzędnych punktów o współrzędnych całkowitych wspólnych dla obu kwadratów (fałsz, jeśli jest pusty, prawda jeśli nie, ).

Wypróbuj online! lub zweryfikuj wszystkie przypadki testowe .

Jak to działa

Ṫṗ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 bajtów

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

Java, 78 bajtów

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

Oktawa, 17 bajtów

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

Ta sama logika, co moja odpowiedź MATLAB powyżej, z tą różnicą, że Octave obsługuje automatyczne rozgłaszanie wymiarów, dzięki czemu możemy [b,b]po prostu zastąpić b.

Wszystkie przypadki testowe tutaj

SmileBASIC, 76 57 bajtów

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

Tworzy duszka o rozmiarze / pozycji pierwszego kwadratu, a następnie sprawdza, czy koliduje z drugim kwadratem.

x86-64 Kod maszynowy, Windows 22 bajtów

Podpis w C ++:

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

Zwraca 0, jeśli kwadraty się nie nakładają, a w przeciwnym razie -1 (0xFFFFFFFF). Wejściami są wektory 2 64-bitowych liczb całkowitych dla x, y i k ( _mm_set_epi64x(x1, x2)itp.).

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 bajtów

Â-›˜P

Port odpowiedzi MATL @Suever , z dodatkową konwersją do wyniku true / falsey. Format wejściowy jest zatem również taki sam:
Pierwsze wejście jako [[x1,y1],[x2,y2]]i drugie wejście jako [k2,k1].

Wypróbuj online lub sprawdź wszystkie przypadki testowe .

Wyjaśnienie:

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