Bu meydan okumada, çakışan iki dikdörtgen verilir ve diğerini kaldırarak oluşturulan dikdörtgenleri hesaplamanız gerekir.

Örneğin, kırmızı dikdörtgeni siyah olandan kaldırırsanız:

Aşağıdaki iki dikdörtgen setinden biriyle sonuçlanırsınız:

Ayrıca aşağıdakileri de ele almanız gerekir:

Daha açık olmak gerekirse:

• A ve B olmak üzere iki dikdörtgenin koordinatlarını gireceksiniz.
• A'nın tüm alanını B olmadan kaplayan en az çakışmayan dikdörtgenlerin çıktısını almanız gerekir.
• Dikdörtgen koordinatlar 4 tamsayı olarak geçirilir. Onları iki çift halinde (iki köşe noktasını temsil eder) veya 4 tamsayı bir demet / liste olarak iletebilirsiniz. Girdilerinizin ve çıktılarınızın tutarlı olması gerekir.
• A ve B mutlaka üst üste gelmeyecek veya dokunmayacak ve her birinin en az 1 alanı olacak

Test senaryoları:

[(0 0) (5 5)] [(3 4) (8 7)]   -> [(0 0) (5 4)] [(0 4) (3 5)] # or [(0 0) (3 5)] [(3 0) (5 4)]
[(2 4) (10 11)] [(5 5) (6 6)]  -> [(2 4) (10 5)] [(2 5) (5 6)] [(6 5) (10 6)] [(2 6) (10 11)]    #Other sets of 4 rectangles are possible
[(3 3) (8 8)] [(0 1) (10 8)]   ->    #No rectangles should be output
[(0 0) (5 5)] [(1 1) (10 2)]   -> [(0 0) (1 5)] [(1 0) (2 1)] [(2 0) (5 5)]  #Other sets of 3 rectangles are possible
[(1 5) (7 8)] [(0 0) (1 10)]   -> [(1 5) (7 8)]  #Only possible output
[(4 1) (10 9)] [(2 5) (20 7)]   -> [(4 1) (10 5)] [(4 7) (10 9)]  #Only possible output
[(1 1) (8 8)] [(0 6) (9 9)]     -> [(1 1) (8 6)]   #Only possible output

Bu bir kod golf , bu yüzden kodunuzu mümkün olduğunca kısa yapın!

Piton 2 , 375 360 345 343 bayt

from itertools import*;P=product
def f(S,M):(l,t),(r,b)=S;(L,T),(R,B)=M;u,v,x,y=(L>=r)+(l<L),(T>=b)+(t<T),(R>=r)+(l<R),(B>=b)+(t<B);return[S]if v==y!=1or u==x!=1else[list(p(p(*zip(*(S+M))),repeat=2))[[43,197,6,199,9,231,142,229,53,189,134,181][int(i,36)]]for i in '38,491,258,2058,8,4B,28,208,7,41,27,461,,4,2,4A'.split(',')[u+2*v+4*x+8*y-12]]

Çevrimiçi deneyin!

DÜZENLEMELER: @notjagan önerilerinden -15; başka bir -15 çözelti dikdörtgenleri dizisini int36 formatına ve kısa bir arama tablosuna yeniden kodlayarak; başka -2, ürünü @musicman'a göre p ile değiştirerek.

İki dikdörtgen alan bir işlevdir, her doğrultuda bir demet ((sol, üst), (sağ, alt)); ortaya çıkan dikdörtgenlerin bir listesini döndürür.

Temel strateji:

     |     |
 0,0 | 1,0 | 2,0
-----A-----+-----
     |     |
 0,1 | 1,1 | 2,1
-----+-----B-----
     |     |
 0,2 | 1,2 | 2,2
     |     |

Yukarıdaki şemada, A ve B noktaları sırasıyla 'Kaynak' dikdörtgenin (ilk doğrultu) sol üst ve sağ alt köşeleridir.

'Maske' dikdörtgenin sol üst (u,v)ve sağ alt köşelerinin her birinin (x,y)bu ızgaraya yerleştiğini görüyoruz.

Bu noktaların her ikisi de ilk veya son sütundaysa; veya ilk veya son satır; o zaman örtüşme olmaz; ve biz sadece Kaynak rect geri dönebiliriz.

Aksi takdirde, geriye kalan 16 dava vardır; örneğin, OP'nin ilk örneği etiketleyebileceğimiz durumdur (1,1),(2,2). Her durum, köşeleri her zaman sol, sağ Kaynak dikdörtgenlerinde veya sol, sağ Maske dikdörtgenlerinde yatay değerlerle koordineli olan bir dizi ortaya çıkan dikdörtgenle eşlenebilir; ve benzer şekilde dikey değerler, Kaynağın üst, alt veya maskeleri için.

Örneğin, için (1,1),(2,2)durum, dikdörtgenler olacağını ((l,t),(T,r))ve ((l,T),(R,b))nerede l,t,r,bve L,T,R,Bsağ ve Kaynak alt, sol üst ve sırasıyla dikdörtgenler maske.

Bu nedenle, koordinatları bu gibi tüm olası kombinasyonlar kümesiyle (bu, product(product(*zip(*)))bitin ne olduğu) eşleştirerek, vakaların her biri için sağlanması gereken bir dizi dikdörtgenle (ki bazı golf-dekompresyondan sonra) eşleyen bir arama tablosu oluşturabiliriz . , listenin geri kalanı hakkındadır).

JavaScript, 115 bayt

f=a=>b=>b.some((n,i)=>(a[i^2]<n)^i/2)?[a]:b.map((n,i)=>a[i&1]<n&&n<a[i|2]&&(p=[...a],p[i^2]=a[i]=n,p)).filter(x=>x)

çakışan versiyon:

f=a=>b=>b.some((n,i)=>(a[i^2]<n)^i/2)?[a]:b.map((n,i)=>a[i&1]<n&&n<a[i|2]&&(p=[...a],p[i^2]=n,p)).filter(x=>x)

Aşağıdaki biçimde giriş yapın: f([1,1,8,8])([0,6,9,9])

Girişi ((x1, y1), (x2, y2)), ((x3, y3), (x4, y4)) olarak belirtin

Aşağıdaki koşullardan herhangi biri karşılanırsa, ilk dikdörtgeni aşağıdaki gibi döndürün:

• x3> x2
• x4 <x1
• y3> y2
• y4 <y1

aksi takdirde

• X1 <x3 <x2 ise, bir dikdörtgen ((x1, y1), (x3, y2)) üretiriz; ve x1'i ayarlayın: = x3
• X1 <x4 <x2 ise, bir dikdörtgen ((x4, y1), (x2, y2)) üretiriz; ve x2'yi ayarlayın: = x4
• Y1 <y3 <y2 ise, bir dikdörtgen ((x1, y1), (x2, y3)) üretiriz; ve y1'i ayarlayın: = y3
• Y1 <y4 <y2 ise, bir dikdörtgen ((x1, y4), (x2, y2)) üretiriz; ve y2'yi ayarlayın: = y4

Java, 268 bayt

class W{public static void main(String[]z) {int a[]={0,0,0,0},i,j,y[]={0,1,4,3,6,1,2,3,4,1,6,5,4,7,6,3};for(i=0;i<4;i+=1){for(j=0;j<4;j+=1){a[j]=Integer.parseInt(z[y[i*4+j]]);}if(a[0]<a[2] && a[1]<a[3]){for(j=0;j<4;j+=1){System.out.println(String.valueOf(a[j]));}}}}}

Ungolfed

class W{
    public static void main(String[]z) {
        int a[]={0,0,0,0},i,j,y[]={0,1,4,3,6,1,2,3,4,1,6,5,4,7,6,3};

        for(i=0;i<4;i+=1){
            for(j=0;j<4;j+=1){
                a[j]=Integer.parseInt(z[y[i*4+j]]);
            }
            if(a[0]<a[2] && a[1]<a[3]){
                for(j=0;j<4;j+=1){
                    System.out.println(String.valueOf(a[j]));
                }
            }
        }
    }
}

Girdiyi bağımsız değişkenler olarak iletir. Misal

java -jar W.jar 0 0 5 5 3 4 8 7

Python 2 , 272 bayt

lambda((a,b),(c,d)),((e,f),(g,h)):[([([[(a,b),(e,min(h,d))]]+[[(g,max(b,f)),(c,d)]]*2+[[(max(a,e),b),(c,f)]]*4+[[(a,h),(min(c,g),d)]])[m-1]for m in M&{1,2,4,8}]if M&{0}else[(a,b),(c,d)])for M in[{(x<e)*1+(x>g)*2+(y<f)*4+(y>h)*8 for x in range(a,c)for y in range(b,d)}]][0]

Çevrimiçi deneyin!

Bu, ilk dikdörtgenin içindeki her hücreyi solluk = 1, aboveness = 4, doğruluk = 2 ve altlık = 8 w / r için diğerine test ederek ve sonucu ORing olarak test ederek çalışır. Diğeri ilk ile = 0 kesişmezse, orijinal döndürülür, aksi takdirde üst üste binme için konaklama ile birlikte bir sol dilim, sağ dilim, üst dilim ve alt dilim kombinasyonu döndürülür.