Date le coordinate degli angoli in alto a sinistra di due quadrati e la loro lunghezza laterale, determinare se i quadrati si sovrappongono. Un quadrato include le linee superiore e sinistra, ma non le linee inferiore e destra. Cioè, un punto (a,b)è all'interno di un quadrato con lunghezza laterale kche inizia da (x,y)if e solo if x <= a < x+ke y <= b < y+k. Un quadrato con lunghezza del lato 0 è degenerato e non verrà considerato qui, quindi ksarà positivo.

Come al solito, si applicano tutte le regole standard. L'input e l'output possono essere in qualsiasi forma sia conveniente, purché sia ​​leggibile dall'uomo e non vi sia alcun calcolo preliminare. Assicurati di specificare quale formato di input usi. Il tuo codice dovrebbe prendere sei numeri e produrre in verità se i quadrati si sovrappongono e falsano diversamente.

Casi test

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

Tutti gli input saranno numeri interi non negativi. Detto questo, mi aspetto che molte o la maggior parte delle soluzioni saranno anche in grado di gestire negativi e galleggianti.

Python, 33 byte

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

Python supporta catene di disuguaglianze anche quando puntano in direzioni opposte.

La coordinata x intervalli [x,x+k)e [X,X+K)sovrappongono fintantoché non si è completamente a destra dell'altro, che significa che endpoint fianco di ogni intervallo è rimasto endpoint diritto dell'altra intervallo.

x<X+K
X<x+k

Il può essere combinato in una disuguaglianza comune -K<X-x<k. Scrivere lo stesso per le coordinate y e collegarle a -Kdà l'espressione

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

MATL, 14 11 10 5 4 byte

tP->

Questa soluzione accetta input sotto forma di due array:

1. Una matrice 2 x 2 che contiene le coordinate degli angoli [x1, y1; x2, y2]
2. Un array 2 x 1 contenente le dimensioni quadrate [k2; k1]

Provalo online

Versione leggermente modificata per eseguire tutti i casi di test

Spiegazione

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

Crea una funzione anonima che può essere valutata come ans(a,b). Accetta due input del seguente formato:

1. Matrice 2 x 2 contenente l'angolo di ogni quadrato come una riga: [x1, y1; x2, y2] .
2. Matrice 2 x 1 contenente le dimensioni dei due quadrati: [k2; k1]

Tutti i casi di test qui .

Spiegazione

Ecco una soluzione non golfata commentata

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

Se d - a ≥ c, il secondo quadrato è alla destra del primo. Allo stesso modo le altre condizioni verificano che non sia a sinistra, in basso o in alto.

Gelatina , 8 byte

Ṫṗ2+µ€f/

L'input è l'elenco nidificato [[x1, y1, k1], [x2, y2, k2]] , l'output è l'elenco di tutte le coordinate incrementali dei punti con coordinate intere comuni a entrambi i quadrati (falsa se vuota, verità se non ).

Provalo online! o verifica tutti i casi di test .

Come funziona

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

Ottava, 17 byte

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

Stessa logica della mia risposta MATLAB sopra, tranne per il fatto che Octave supporta la trasmissione automatica delle dimensioni in modo che possiamo sostituirla [b,b]semplicementeb .

Tutti i casi di test qui

SmileBASIC, 76 57 byte

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

Crea uno sprite con le dimensioni / posizione del primo quadrato, quindi controlla se si scontra con il secondo quadrato.

x86-64 Codice macchina, Windows 22 byte

Firma C ++:

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

Restituisce 0 se i quadrati non si sovrappongono e -1 (0xFFFFFFFF) in caso contrario. Gli ingressi sono vettori di 2 numeri interi a 64 bit per x, ye k ( _mm_set_epi64x(x1, x2)ecc.).

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

Porto di @Suever risposta MATL s' , con l'aggiunta di conversione ad un risultato truthy / Falsey. Pertanto, anche il formato di input è lo stesso:
primo input come [[x1,y1],[x2,y2]]e secondo input come [k2,k1].

Provalo online o verifica tutti i casi di test .

Spiegazione:

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