Inclusion-Exclusion pozwala obliczyć rozmiary niektórych związków i przecięć między zestawami, znając niektóre inne wartości. Nie wyjaśnię tego dokładnie, ale twoim wyzwaniem jest wizualizacja wykluczenia włączenia na diagramie Venna.

Ponieważ jestem miły, będziesz używać prostokątów, a nie kół.

Otrzymasz listę prostokątów oznaczonych współrzędnymi górnego lewego i prawego dolnego rogu w dowolnym rozsądnym formacie (lista 4 krotek, lista par par, lista par itp.). Możesz założyć, że wszystkie współrzędne są nieujemne i mieszczą się w (rozsądnym) zakresie liczbowym twojego języka (określ, co to jest, jeśli jest mniejsze niż 128). Możesz wybrać opcję obejmującą lewą lub wyłączną lewą i obejmującą prawą lub wyłączną prawą. Bez względu na wybrany format możesz założyć, że wszystkie prostokąty mają co najmniej 1x1.

Następnie musisz narysować każdy prostokąt na ekranie (obszar roboczy ASCII) za pomocą pojedynczej spacji k, którą możesz wybrać.

Jednak za każdym razem, gdy dwa prostokąty zachodzą na siebie, nakładający się obszar zostanie narysowany za pomocą innej spacji l != k, również do wyboru.

Ilekroć trzy prostokąty pokrywają obszar nakładających powinien być narysowany k, a dla nieparzystej liczby prostokątów obejmującego, ki nawet numer, l.

Tłem powinny być pojedyncze białe znaki ( 0x20).

Przypadki testowe ( 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


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

Notatki

• Spacje wiodące i znaki nowej linii (które występują, jeśli współrzędna minimalna nie jest 0, 0), muszą być obecne
• Wszelkie spacje i znaki nowej linii są dozwolone w rozsądnym zakresie (tzn. Nie wyświetlaj śladu jak 100000000 znaków nowej linii, to po prostu denerwujące)
• Osie x i y mogą być skierowane w obie strony, ale musisz być spójny i określić, który (domyślnie jest to x prawo i y-dół)
• współrzędne mogą być indeksowane 0, 1 lub 2.

Referencyjna implementacja protonu

To jest golf golfowy , więc celem jest posiadanie najkrótszego kodu. Miłej gry w golfa!

Procedura kodu maszynowego 6502 (C64), 57 bajtów

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

Jest to kod niezależny od pozycji, umieść go gdzieś w pamięci RAM i użyj poprawnego adresu początkowego, wywołując go sys.

Demo online (adres początkowy$C000/49152).

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

Przykład: sys49152,0,0,9,9,1,1,10,10,2,2,11,11

W rozsądnych zakresach liczb: naturalny zakres na tym 8-bitowym komputerze to [0–255], a program zaakceptuje to jako parametry. Ale ekran C64 ma tylko 40 kolumn i 25 wierszy, co ogranicza rozsądny zakres do [0–40] dla wartości x i [0–25] dla wartości y. Używanie innych wartości będzie miało nieprzewidywalne zachowanie.

skomentował listę dezasemblacji:

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 bajtów

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)

Wypróbuj online!

Węgiel drzewny , 40 bajtów

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

Wypróbuj online! Link jest do pełnej wersji kodu. Będzie 6 bajtów krótszy, gdy tylko @ ASCII naprawi błąd w Charcoal . Pobiera dane wejściowe jako zakończoną znakiem nowej linii rozdzieloną spacjami listę współrzędnych. Wyjaśnienie:

ＷＳ«

Pętlę nad każdą linią wejścia, aż do osiągnięcia pustej linii.

≔Ｉ⪪ι ι

Podziel linię na listę współrzędnych.

Ｆ…§ι⁰§ι²«

Pętla nad wszystkimi współrzędnymi X.

Ｊκ§ι¹

Przejdź na górę kolumny.

ＵＭ

Mapa nad każdym z ...

ＫＤ⁻§ι³§ι¹↓

... wszystkie komórki w kolumnie ...

§10Σλ

... nowa wartość jest, 0jeśli zawierają 1, w przeciwnym razie 1. Edycja: Wkrótce po napisaniu tego, Węgiel zmienił zachowanie, ¬dzięki czemu Ｉ¬Σλdziała tutaj, aby zapisać 1 bajt.

Python 2 , 181 bajtów

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

Wypróbuj online!

C (gcc) , 205 bajtów

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

Wypróbuj online!

R , 196 189 bajtów

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

Wypróbuj online!

Kod odczytuje dane wejściowe jako standardowe, ustawione jako krotka x1 y1 x2 y2, gdzie x to kolumna, a y to rząd. Używam 1 i 2 dla poziomów nakładania się, gdzie 1 reprezentuje poziom parzysty.

Zapisano 7 bajtów dzięki user2390246.

Raku , 54 bajty

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

Wypróbuj online!

Pobiera dane wejściowe jako płaską listę współrzędnych jako włącznie współrzędnych, tj. Dane x1,y1,x2,y2,x1,y1,x2,y2...wyjściowe jako listę znaków z kbytem 1i lbytem 0.

Wyjaśnienie:

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

Galaretka , 43 bajty

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

Wypróbuj online!

Wyjaśnienie

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