Bao gồm-Loại trừ cho phép bạn tính toán kích thước của một số hiệp và giao giữa các bộ biết một số giá trị khác. Tôi sẽ không giải thích chính xác, nhưng thách thức của bạn là hình dung loại trừ bao gồm trên Biểu đồ Venn.

Bởi vì tôi đẹp, bạn sẽ sử dụng hình chữ nhật, không phải hình tròn.

Bạn sẽ được cung cấp một danh sách các hình chữ nhật được biểu thị bằng tọa độ góc trên cùng bên trái và dưới cùng bên phải ở bất kỳ định dạng hợp lý nào (danh sách 4 tuples, danh sách các cặp, danh sách các cặp, v.v.). Bạn có thể giả sử rằng tất cả các tọa độ là không âm và trong phạm vi số (hợp lý) của ngôn ngữ của bạn (vui lòng chỉ định nó là gì nếu nó nhỏ hơn 128). Bạn có thể chọn bao gồm trái hoặc độc quyền và bao gồm phải hoặc độc quyền. Bất kể định dạng bạn đã chọn, bạn có thể giả sử tất cả các hình chữ nhật ít nhất là 1x1.

Sau đó, bạn phải vẽ ra từng hình chữ nhật trên màn hình (khung vẽ ASCII) bằng một ký tự không phải khoảng trắng duy nhất, là ký tự kdo bạn chọn.

Tuy nhiên, bất cứ khi nào hai hình chữ nhật trùng nhau, khu vực chồng lấp sẽ được vẽ bằng một ký tự không phải khoảng trắng khác l != k, cũng là của bạn để chọn.

Bất cứ khi nào ba hình chữ nhật trùng nhau, khu vực chồng lấp sẽ được vẽ kvà cho một số lượng hình chữ nhật lẻ k, và một số chẵn , l.

Nền nên là khoảng trắng đơn ( 0x20).

Các trường hợp thử nghiệm ( k = "#", l = ".")

0 0 9 9
1 1 10 10
2 2 11 11

#########  
#........# 
#.#######.#
#.#######.#
#.#######.#
#.#######.#
#.#######.#
#.#######.#
#.#######.#
 #........#
  #########

1 1 3 3
2 2 4 4


 ## 
 #.#
  ##

1 1 9 9
2 2 8 8
3 3 7 7


 ########
 #......#
 #.####.#
 #.####.#
 #.####.#
 #.####.#
 #......#
 ########

Ghi chú

• Không gian hàng đầu và dòng mới (xảy ra nếu tọa độ tối thiểu không 0, 0) phải có mặt
• Bất kỳ dấu cách và dòng mới nào đều được phép ở một mức độ hợp lý (ví dụ: không theo dõi như 100000000 dòng mới, điều đó thật khó chịu)
• trục x và y có thể phải đối mặt theo một trong hai cách nhưng bạn phải nhất quán và chỉ định cái nào (mặc định là x- phải và y- xuống)
• tọa độ có thể là 0-, 1- hoặc 2- được lập chỉ mục.

Tham khảo thực hiện Proton

Đây là môn đánh gôn , vì vậy mục tiêu là có mã ngắn nhất. Chúc bạn chơi golf vui vẻ!

Thường trình mã máy 6502 (C64), 57 byte

20 44 E5 A0 03 84 FB 20 9B B7 A4 FB 96 22 C6 FB 10 F5 85 FC A6 24 20 F0 E9 A4
25 B1 D1 09 01 49 02 91 D1 C8 C4 23 D0 F3 E8 E4 22 D0 E9 A9 2C C5 FC F0 D0 A5
C6 F0 FC C6 C6 4C 44 E5

Đây là mã độc lập với vị trí, đặt nó ở đâu đó trong RAM và sử dụng đúng địa chỉ bắt đầu gọi nó bằng sys.

Bản demo trực tuyến (địa chỉ bắt đầu$C000/49152).

Sử dụng: sys<startaddress>,<x1>,<y1>,<x2>,<y2>[,<x1>,<y1>,<x2>,<y2>[,...]]

Thí dụ: sys49152,0,0,9,9,1,1,10,10,2,2,11,11

Trên phạm vi số hợp lý: Phạm vi tự nhiên trên máy 8 bit này là [0-255] và chương trình sẽ chấp nhận điều này dưới dạng tham số. Nhưng màn hình C64 chỉ có 40 cột và 25 hàng, do đó giới hạn phạm vi hợp lý là [0-40] cho các giá trị x và [0-25] cho các giá trị y. Sử dụng các giá trị khác sẽ có hành vi không thể đoán trước.

bình luận tháo gỡ danh sách:

20 44 E5    JSR $E544           ; clear screen
 .mainloop:
A0 03       LDY #$03            ; index for reading coordinates
84 FB       STY $FB
 .inputrect:
20 9B B7    JSR $B79B           ; read 8bit value from parameter
A4 FB       LDY $FB
96 22       STX $22,Y           ; and store to $22-$25
C6 FB       DEC $FB
10 F5       BPL .inputrect      ; parameter reading loop
85 FC       STA $FC             ; store last character
A6 24       LDX $24             ; load y1
 .rowloop:
20 F0 E9    JSR $E9F0           ; get pointer to screen row in $d1/$d2
A4 25       LDY $25             ; load x1
 .colloop:
B1 D1       LDA ($D1),Y         ; load character at screen position
09 01       ORA #$01            ; set bit 0 ( -> '#')
49 02       EOR #$02            ; toggle bit 1 (toggle between '#' and '!' )
91 D1       STA ($D1),Y         ; store character at screen position
C8          INY                 ; next x
C4 23       CPY $23             ; equals x2?
D0 F3       BNE .colloop        ; no -> repeat
E8          INX                 ; next y
E4 22       CPX $22             ; equals y2?
D0 E9       BNE .rowloop        ; no -> repeat
A9 2C       LDA #$2C            ; load ','
C5 FC       CMP $FC             ; compare with last character from parsing
F0 D0       BEQ .mainloop       ; if ',', repeat reading coordinates
 .waitkey:
A5 C6       LDA $C6             ; load input buffer size
F0 FC       BEQ .waitkey        ; and repeat until non-empty
C6 C6       DEC $C6             ; set back to empty
4C 44 E5    JMP $E544           ; clear screen

Python 2 , 218 192 189 185 158 154 147 byte

def f(l):_,_,a,b=map(range,map(max,zip(*l)));print'\n'.join(''.join((' '+'#.'*len(l))[sum((x<=i<X)*(y<=j<Y)for x,y,X,Y in l)]for i in a)for j in b)

Hãy thử trực tuyến!

Than , 40 byte

ＷＳ«≔Ｉ⪪ι ιＦ…§ι⁰§ι²«Ｊκ§ι¹ＵＭＫＤ⁻§ι³§ι¹↓§10Σλ

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Sẽ ngắn hơn 6 byte một lần chỉ khi @ ASCII sửa lỗi trong Than . Đưa đầu vào dưới dạng danh sách kết thúc dòng mới của danh sách tọa độ được phân tách bằng dấu cách. Giải trình:

ＷＳ«

Lặp lại từng dòng đầu vào cho đến khi đạt được một dòng trống.

≔Ｉ⪪ι ι

Chia dòng thành một danh sách tọa độ.

Ｆ…§ι⁰§ι²«

Lặp lại tất cả các tọa độ X.

Ｊκ§ι¹

Nhảy lên đỉnh cột.

ＵＭ

Bản đồ trên mỗi ...

ＫＤ⁻§ι³§ι¹↓

... tất cả các ô trong cột ...

§10Σλ

... Giá trị mới là 0nếu chúng chứa 1, nếu không 1. Chỉnh sửa: Ngay sau khi viết bài này, Char than đã thay đổi hành vi ¬để Ｉ¬Σλhoạt động ở đây để tiết kiệm 1 byte.

Python 2 , 181 byte

l=input()
_,_,x,y=map(max,zip(*l))
m=eval(`[[32]*x]*y`)
for v,w,x,y in l:
 for i in range(v,x):
	for j in range(w,y):
	 m[i][j]=max(m[i][j]^1,34)
for n in m:print''.join(map(chr,n))

Hãy thử trực tuyến!

C (gcc) , 205 byte

x[999][999];a;b;c;d;j;k;l;m;n;main(i){for(;scanf("%d %d %d %d",&a,&b,&c,&d)>3;m=d>m?d:m,n=c>n?c:n)for(i=b;i<d;++i)for(j=a;j<c;++j)x[i][j]=x[i][j]^2|1;for(;k<n||++l<(k=0,puts(""),m);putchar(x[l][k++]+32));}

Hãy thử trực tuyến!

R , 196 189 byte

m=matrix
x=m(scan(file("stdin")),4)
y=m(0,max(x[3,]),max(x[4,]))
n=ncol(x)
while(n){z=x[,n]  
i=z[1]:z[3]
j=z[2]:z[4]
y[i,j]=y[i,j]+1
n=n-1}
i=!y
y=y%%2+1
y[i]=' '
cat(rbind(y,'\n'),sep='')

Hãy thử trực tuyến!

Mã đọc đầu vào là stdin, được sắp xếp dưới dạng một x1 y1 x2 y2 tuple, trong đó x là cột và y là hàng. Tôi đang sử dụng 1 và 2 cho các cấp độ chồng lấp, trong đó 1 đại diện cho một mức chẵn.

Đã lưu 7 byte nhờ người dùng2390246.

Raku , 54 byte

{my@a;{@a[$^a..$^b;$^c..$^d]X+^=1}for $_;@a >>~|>>' '}

Hãy thử trực tuyến!

Đưa đầu vào như một danh sách phẳng tọa độ như tọa độ bao gồm, ví dụ x1,y1,x2,y2,x1,y1,x2,y2...và kết quả đầu ra như một danh sách danh sách các nhân vật với kviệc 1và ltrở 0.

Giải trình:

{                                                    }  # Anonymous codeblock
 my@a;    # Declare an array
      {                          }for $_;    # Loop over the input
       @a[                 ]   # Indexing into @a
          $^a..$^b             # The range of rows
                  ;$^c..$^d    # And the range of columns for each
                            X        # And for each cell
                             +^=1    # Set it to itself bitwise XOR'd with 1
                         # Cells not yet accessed are numerically zero
                                         @a >>~|>>' '   # Stringwise OR each cell with a space
                         # Cells not yet accessed are stringily empty         

Thạch , 43 byte

+µ>2Ḥạ
ạ1ẋ$0ẋ⁸¤;µ/€«þ/µ€z0z€0Z€Zz€0Z€ç"/o⁶Y

Hãy thử trực tuyến!

Giải trình

+µ>2Ḥạ                                Helper Link; combines final rectangles (0 is blank, 1 is covered, 2 is uncovered)
+                                     add the two values
 µ                                    (with the sum...)
  >2                                  check if it's greater than two
    Ḥ                                 double the result (2 if it's 3 or 4, 0 if it's 0, 1, or 2)
     ạ                                absolute difference (0 should take whatever the other thing's value is, 1+1 and 2+2 should give 2, 1+2 and 2+1 should give 1)
ạ1ẋ$0ẋ⁸¤;µ/€«þ/µ€z0z€0Z€Zz€0Z€ç"/o⁶Y  Main Link
               µ€                     For each rectangle stored as [[x1, x2], [y1, y2]]
         µ/€                          For each of [a, b] = [x1, x2] and [y1, y2], reduce it by (in other words, use a dyad on a size-2 list)
 1ẋ$                                  repeat [1]            times
ạ                                                abs(a - b)
        ;                             and append to
    0ẋ ¤                              [0] repeated   times
      ⁸                                            a
            «þ/                       and reduce by minimum outer product table (take the outer product table, by minimum, of the x results and the y results)
                                      [NOTE] At this point, we have a list of matrices with 0s as blanks and 1 as covered
                 z0z€0Z€Zz€0Z€        Make all of the matrices the same size:
                 z0                   zip, fill with 0 (all matrices are the same length, but not width, and now are lists of row-wise lists of rows)
                   z€0                zip each, fill with 0 (all rows are the same length within their row-wise lists, and are now lists of row-wise lists of columns)
                      Z€              zip each (flip rows back to lists of row-lists of rows)
                        Z             zip (flip back to matrices); however, if a matrix is smaller on both axes, its rows will not be the same length
                         z€0          zip each, fill with 0 (all rows in each matrix are the same length and the value is now a list of transposed matrices)
                            Z€        zip each (the value is now a list of matrices, all the same length, filled with 0 (empty space))
                              ç"/     reduce by (vectorized) the relation in the Helper Link (to combine all of the final values)
                                 o⁶   logical OR with " "; replace 0s with spaces
                                   Y  join with newlines (formatting)