Bestimmen Sie anhand der Koordinaten der oberen linken Ecken zweier Quadrate und ihrer Seitenlängen, ob sich die Quadrate überlappen. Ein Quadrat enthält die oberen und linken Linien, jedoch nicht die unteren und rechten Linien. Das heißt, ein Punkt (a,b)befindet sich innerhalb eines Quadrats mit einer Seitenlänge k, die (x,y)genau dann beginnt, wenn x <= a < x+kund y <= b < y+k. Ein Quadrat mit der Seitenlänge 0 ist entartet und wird hier nicht berücksichtigt, ist also kpositiv.

Wie üblich gelten alle Standardregeln. Die Eingabe und Ausgabe kann in einer beliebigen Form erfolgen, sofern sie für den Menschen lesbar ist und keine Vorberechnung erfolgt. Stellen Sie sicher, dass Sie angeben, welches Eingabeformat Sie verwenden. Ihr Code sollte sechs Zahlen annehmen und wahrheitsgemäß ausgeben, wenn sich die Quadrate überlappen und ansonsten falsch sind.

Testfälle

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

Alle Eingaben sind nicht negative ganze Zahlen. Ich gehe jedoch davon aus, dass viele oder die meisten Lösungen auch mit Negativen und Floats umgehen können.

Python, 33 Bytes

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

Python unterstützt Ungleichungsketten, auch wenn sie in entgegengesetzte Richtungen zeigen.

Die x-Koordinatenintervalle [x,x+k)und [X,X+K)überlappen sich, solange sich keiner vollständig rechts vom anderen befindet. Dies bedeutet, dass der linke Endpunkt jedes Intervalls links vom rechten Endpunkt des anderen Intervalls liegt.

x<X+K
X<x+k

Das kann zu einer gemeinsamen Ungleichung kombiniert werden -K<X-x<k. Das gleiche für y-Koordinaten zu schreiben und an zu spleißen, -Kergibt den Ausdruck

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

MATL, 14 11 10 5 4 Bytes

tP->

Diese Lösung akzeptiert Eingaben in Form von zwei Arrays:

1. Eine 2 x 2-Matrix, die die Koordinaten der Ecken enthält [x1, y1; x2, y2]
2. Ein 2 x 1-Array mit den quadratischen Abmessungen [k2; k1]

Probieren Sie es online aus

Leicht modifizierte Version, um alle Testfälle auszuführen

Erläuterung

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

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

Erstellt eine anonyme Funktion, die als ausgewertet werden kann ans(a,b). Akzeptiert zwei Eingaben im folgenden Format:

1. 2 x 2 Matrix, die die Ecke jedes Quadrats als Reihe enthält : [x1, y1; x2, y2].
2. 2 x 1 Array mit der Größe der beiden Quadrate: [k2; k1]

Alle Testfälle hier .

Erläuterung

Hier ist eine kommentierte Lösung ohne Golf

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

Wenn d - a ≥ c ist, befindet sich das zweite Quadrat rechts vom ersten. In ähnlicher Weise prüfen die anderen Bedingungen, ob es nicht links, unten oder oben ist.

Gelee , 8 Bytes

Ṫṗ2+µ€f/

Eingabe ist die verschachtelte Liste [[x1, y1, k1], [x2, y2, k2]] , Ausgabe ist die Liste aller inkrementierten Koordinaten von Punkten mit ganzzahligen Koordinaten, die beiden Quadraten gemeinsam sind (falsch, wenn leer, wahr, wenn nicht ).

Probieren Sie es online aus! oder überprüfen Sie alle Testfälle .

Wie es funktioniert

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

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

Java, 78 Bytes

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

Oktave, 17 Bytes

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

Dieselbe Logik wie meine obige MATLAB-Antwort , außer dass Octave die automatische Übertragung von Dimensionen unterstützt, sodass wir sie [b,b]einfach ersetzen können b.

Alle Testfälle hier

SmileBASIC, 76 57 Bytes

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

Erstellt ein Sprite mit der Größe / Position des ersten Quadrats und prüft dann, ob es mit dem zweiten Quadrat kollidiert.

x86-64 Maschinencode, Windows 22 Byte

C ++ - Signatur:

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

Gibt 0 zurück, wenn sich die Quadrate nicht überlappen, andernfalls -1 (0xFFFFFFFF). Eingänge sind Vektoren von 2 64-Bit-Ganzzahlen für x, y und k ( _mm_set_epi64x(x1, x2)usw.).

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 Bytes

Â-›˜P

Port der MATL -Antwort von @Suever mit zusätzlicher Konvertierung in ein wahrheitsgemäßes / falsches Ergebnis. Das Eingabeformat ist daher auch das gleiche:
Erste Eingabe als [[x1,y1],[x2,y2]]und zweite Eingabe als [k2,k1].

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

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