Penyertaan-Pengecualian memungkinkan Anda menghitung ukuran beberapa serikat pekerja dan persimpangan antara set yang mengetahui beberapa nilai lainnya. Saya tidak akan menjelaskannya dengan tepat, tetapi tantangan Anda adalah memvisualisasikan inklusi-pengecualian pada Diagram Venn.

Karena saya baik, Anda akan menggunakan persegi panjang, bukan lingkaran.

Anda akan diberikan daftar persegi panjang yang dilambangkan dengan koordinat sudut kiri atas dan kanan bawah dalam format yang masuk akal (daftar 4-tupel, daftar pasangan berpasangan, daftar pasangan, dll). Anda dapat mengasumsikan bahwa semua koordinat adalah non-negatif dan berada dalam rentang angka (wajar) bahasa Anda (sebutkan apa itu jika kurang dari 128). Anda dapat memilih untuk menjadi inklusif kiri atau eksklusif kiri dan inklusif kanan atau eksklusif. Terlepas dari format yang Anda pilih, Anda dapat mengasumsikan semua persegi panjang setidaknya 1x1.

Kemudian, Anda harus menggambar setiap persegi panjang di layar (kanvas ASCII) menggunakan karakter non-spasi tunggal k, yang menjadi milik Anda untuk memilih.

Namun, setiap kali dua persegi panjang tumpang tindih, area yang tumpang tindih harus digambar dengan karakter non-spasi putih lain l != k, juga milik Anda untuk dipilih.

Setiap kali tiga persegi panjang tumpang tindih, daerah yang tumpang tindih harus digambar k, dan untuk jumlah ganjil persegi panjang yang meliputi k,, dan angka genap l,.

Latar belakang harus spasi tunggal ( 0x20).

Kasus Uji ( 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


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

Catatan

• Ruang utama dan baris baru (yang terjadi jika koordinat minimum tidak 0, 0) harus ada
• Setiap spasi tambahan dan baris baru diizinkan sampai batas tertentu (misalnya, jangan jejak seperti 100000000 baris baru, itu hanya mengganggu)
• sumbu x- dan y- dapat menghadap ke dua arah tetapi Anda harus konsisten dan menentukan yang mana (defaultnya adalah x- benar dan turun)
• koordinat dapat diindeks 0-, 1-, atau 2-.

Referensi Implementasi Proton

Ini adalah kode-golf , jadi tujuannya adalah memiliki kode terpendek. Selamat bermain golf!

6502 rutin kode mesin (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

Ini adalah kode posisi-independen, letakkan di suatu tempat di RAM dan gunakan alamat awal yang benar memanggilnya sys.

Demo online (alamat mulai$C000/49152).

Pemakaian: sys<startaddress>,<x1>,<y1>,<x2>,<y2>[,<x1>,<y1>,<x2>,<y2>[,...]]

Contoh: sys49152,0,0,9,9,1,1,10,10,2,2,11,11

Pada rentang angka wajar: Rentang alami pada mesin 8-bit ini adalah [0-255], dan program akan menerima ini sebagai parameter. Tetapi layar C64 hanya memiliki 40 kolom dan 25 baris, sehingga membatasi rentang yang masuk akal untuk [0-40] untuk nilai x dan [0-25] untuk nilai y. Menggunakan nilai-nilai lain akan memiliki perilaku yang tidak dapat diprediksi.

berkomentar daftar pembongkaran:

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)

Cobalah online!

Arang , 40 byte

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

Cobalah online! Tautan adalah untuk mengucapkan versi kode. Akan lebih pendek 6 byte setelah @ ASCII-only memperbaiki bug di Charcoal . Mengambil input sebagai daftar koordinat yang dipisahkan ruang yang diakhiri baris baru. Penjelasan:

ＷＳ«

Ulangi setiap baris input hingga baris kosong tercapai.

≔Ｉ⪪ι ι

Bagi garis menjadi daftar koordinat.

Ｆ…§ι⁰§ι²«

Lingkari semua koordinat X.

Ｊκ§ι¹

Lompat ke bagian atas kolom.

ＵＭ

Petakan masing-masing ...

ＫＤ⁻§ι³§ι¹↓

... semua sel di kolom ...

§10Σλ

... nilai baru adalah 0jika mengandung 1, jika tidak 1. Sunting: Segera setelah menulis ini, Charcoal mengubah perilaku ¬sehingga Ｉ¬Σλberfungsi di sini untuk menghemat 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))

Cobalah online!

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

Cobalah online!

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='')

Cobalah online!

Kode membaca input sebagai stdin, disusun sebagai tuple x1 y1 x2 y2, di mana x adalah kolom dan y adalah baris. Saya menggunakan 1 dan 2 untuk level yang tumpang tindih, di mana 1 mewakili level genap.

Disimpan 7 byte berkat pengguna2390246.

Raku , 54 byte

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

Cobalah online!

Mengambil input sebagai daftar datar koordinat sebagai koordinat inklusif, yaitu x1,y1,x2,y2,x1,y1,x2,y2...dan output sebagai daftar daftar karakter dengan kmakhluk 1dan lmakhluk 0.

Penjelasan:

{                                                    }  # 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         

Jelly , 43 byte

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

Cobalah online!

Penjelasan

+µ>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)