İki karenin sol üst köşelerinin koordinatları ve yan uzunlukları göz önüne alındığında, karelerin çakışıp çakışmadığını belirleyin. Kare, üst ve sol çizgileri içerir, ancak alt ve sağ çizgileri içermez. Olduğunu, bir nokta (a,b)yan uzunluğu olan bir kare içinde olduğunu kolduğunu başlar de (x,y)ancak ve ancak x <= a < x+kve y <= b < y+k. Yan uzunluğu 0 olan bir kare dejenere olur ve burada dikkate alınmayacaktır, bu nedenle kpozitif olacaktır.

Her zamanki gibi, tüm standart kurallar geçerlidir. Girdi ve çıktı, insan tarafından okunabilir olduğu ve ön hesaplama olmadığı sürece uygun olan her şekilde olabilir. Hangi giriş biçimini kullandığınızdan emin olun. Kareler çakışıyorsa veya yanlışsa, kodunuz altı sayı almalı ve doğruluk vermelidir.

Test Durumları

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

Tüm girdiler negatif olmayan tamsayılar olacaktır. Bununla birlikte, birçok ya da çoğu çözümün negatifleri ve şamandıraları da ele alabileceğini umuyorum.

Python, 33 bayt

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

Python, zıt yönlere işaret etseler bile eşitsizlik zincirlerini destekler.

X-koordinat aralıkları [x,x+k)ve [X,X+K)hiçbiri diğerinin tamamen sağında olmadığı sürece üst üste biniyor, yani her aralığın sol uç noktası diğer aralığın sağ uç noktasının solunda kalıyor.

x<X+K
X<x+k

Ortak bir eşitsizlik şeklinde birleştirilebilir -K<X-x<k. Y koordinatları ve raptetme için aynı yazma bunları de -Kifade verir

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

MATL, 14 11 10 5 4 bayt

tP->

Bu çözüm girişi iki dizi şeklinde kabul eder:

1. Köşelerin koordinatlarını içeren 2 x 2 matris [x1, y1; x2, y2]
2. Kare boyutları içeren 2 x 1 dizi [k2; k1]

Çevrimiçi Deneyin

Tüm test senaryolarını çalıştırmak için biraz değiştirilmiş versiyon

açıklama

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

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

Olarak değerlendirilebilen anonim bir işlev oluşturur ans(a,b). Aşağıdaki biçimde iki girişi kabul eder:

1. Arka arkaya her karenin köşe ihtiva eden 2 x 2 matrisi: [x1, y1; x2, y2].
2. İki karenin boyutunu içeren 2 x 1 dizi: [k2; k1]

Tüm test örnekleri burada .

açıklama

İşte yorum yapılmamış bir golf çözümü

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

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

Eğer D - bir ≥ C , daha sonra ikinci kare birinci sağında. Benzer şekilde, diğer koşullar bunun solda, aşağıda veya üstünde olmadığını kontrol eder.

Jöle , 8 bayt

Ṫṗ2+µ€f/

Girdi yuvalanmış listedir [[x1, y1, k1], [x2, y2, k2]] , çıktı her iki karede ortak olan tamsayı koordinatlarına sahip noktaların tüm artan koordinatlarının listesidir (boşsa falsy, değilse doğruluk ).

Çevrimiçi deneyin! veya tüm test senaryolarını doğrulayın .

Nasıl çalışır

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

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

Java, 78 bayt

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

Oktav, 17 bayt

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

Yukarıdaki MATLAB cevabımla aynı mantık , ancak Octave boyutların otomatik yayınlanmasını destekliyor, böylece [b,b]basitçe değiştirebiliriz b.

Tüm test örnekleri burada

SmileBASIC, 76 57 bayt

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

İlk karenin boyutu / konumu ile bir hareketli grafik oluşturur, ardından ikinci kareyle çarpışıp çarpışmadığını kontrol eder.

x86-64 Makine kodu, Windows 22 bayt

C ++ imzası:

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

Kareler çakışmazsa 0, aksi takdirde -1 (0xFFFFFFFF) döndürür. Girişler, x, y ve k ( _mm_set_epi64x(x1, x2)vb.) İçin 2 64 bit tamsayı vektörüdür .

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 bayt

Â-›˜P

Bağlantı noktası @Suever'in MATL cevabı , doğru / falsey sonucuna ek dönüşüm. Bu nedenle girdi biçimi de aynıdır:
İlk giriş [[x1,y1],[x2,y2]]ve ikinci giriş [k2,k1].

Çevrimiçi deneyin veya tüm test senaryolarını doğrulayın .

Açıklama:

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