Étant donné les coordonnées des coins supérieurs gauches de deux carrés et leurs longueurs latérales, déterminez si les carrés se chevauchent. Un carré comprend les lignes supérieure et gauche, mais pas les lignes inférieure et droite. Autrement dit, un point se (a,b)trouve à l'intérieur d'un carré dont la longueur latérale kcommence à (x,y)si et seulement si x <= a < x+ket y <= b < y+k. Un carré avec une longueur de côté 0 est dégénéré et ne sera pas considéré ici, il ksera donc positif.

Comme d'habitude, toutes les règles standard s'appliquent. L'entrée et la sortie peuvent être sous la forme qui convient, tant qu'elles sont lisibles par l'homme et sans précalcul. Assurez-vous de spécifier le format d'entrée que vous utilisez. Votre code doit prendre six chiffres et afficher la vérité si les carrés se chevauchent et fausser sinon.

Cas de 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

Toutes les entrées seront des entiers non négatifs. Cela dit, je m'attends à ce que la plupart ou la plupart des solutions soient également capables de gérer les négatifs et les flottants.

Python, 33 octets

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

Python prend en charge les chaînes d'inégalités même lorsqu'elles pointent dans des directions opposées.

Les intervalles coordonnées x [x,x+k)et se [X,X+K)chevauchent tant que ni l' un est complètement à droite de l'autre, ce qui signifie que extrémité gauche de chaque intervalle est laissé de extrémité droite de l'autre intervalle.

x<X+K
X<x+k

Le peut être combiné en une inégalité commune -K<X-x<k. Écrire la même chose pour les coordonnées y et les épisser -Kdonne l'expression

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

MATL, 14 11 10 5 4 octets

tP->

Cette solution accepte les entrées sous la forme de deux tableaux:

1. Une matrice 2 x 2 qui contient les coordonnées des coins [x1, y1; x2, y2]
2. Un tableau 2 x 1 contenant les dimensions carrées [k2; k1]

Essayez-le en ligne

Version légèrement modifiée pour exécuter tous les cas de test

Explication

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

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

Crée une fonction anonyme qui peut être évaluée comme ans(a,b). Accepte deux entrées du format suivant:

1. Matrice 2 x 2 contenant le coin de chaque carré comme une ligne: [x1, y1; x2, y2].
2. Tableau 2 x 1 contenant la taille des deux carrés: [k2; k1]

Tous les cas de test ici .

Explication

Voici une solution non golfée commentée

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

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

Si d - a ≥ c, le deuxième carré est à droite du premier. De même les autres conditions vérifient qu'il ne se trouve pas à gauche, en dessous ou au dessus.

Gelée , 8 octets

Ṫṗ2+µ€f/

L'entrée est la liste imbriquée [[x1, y1, k1], [x2, y2, k2]] , la sortie est la liste de toutes les coordonnées incrémentées des points avec des coordonnées entières communes aux deux carrés (fausse si vide, véridique sinon ).

Essayez-le en ligne! ou vérifiez tous les cas de test .

Comment ça fonctionne

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

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

Java, 78 octets

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

Octave, 17 octets

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

Même logique que ma réponse MATLAB ci-dessus, sauf que Octave prend en charge la diffusion automatique des dimensions afin que nous puissions les remplacer [b,b]simplement b.

Tous les cas de test ici

SmileBASIC, 76 57 octets

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

Crée un sprite avec la taille / position du premier carré, puis vérifie s'il entre en collision avec le deuxième carré.

Code machine x86-64, Windows 22 octets

Signature C ++:

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

Renvoie 0 si les carrés ne se chevauchent pas et -1 (0xFFFFFFFF) sinon. Les entrées sont des vecteurs de 2 entiers 64 bits pour x, y et k ( _mm_set_epi64x(x1, x2)etc.).

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 octets

Â-›˜P

Réponse MATL du port de @Suever , avec conversion supplémentaire en un résultat truey / falsey. Le format d'entrée est donc également le même:
première entrée as [[x1,y1],[x2,y2]]et deuxième entrée as [k2,k1].

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

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