Mit Inclusion-Exclusion können Sie die Größe einiger Gewerkschaften und Schnittpunkte zwischen Gruppen berechnen, wobei Sie einige der anderen Werte kennen. Ich werde es nicht genau erklären, aber Ihre Herausforderung besteht darin, Einschluss-Ausschluss in einem Venn-Diagramm zu visualisieren.

Weil ich nett bin, wirst du Rechtecke verwenden, keine Kreise.

Sie erhalten eine Liste von Rechtecken, die durch Koordinaten der oberen linken und unteren rechten Ecke in einem beliebigen vernünftigen Format gekennzeichnet sind (Liste von 4 Tupeln, Liste von Paarpaaren, Liste von Paaren usw.). Sie können davon ausgehen, dass alle Koordinaten nicht negativ sind und innerhalb des (angemessenen) Zahlenbereichs Ihrer Sprache liegen (bitte geben Sie an, was es ist, wenn es weniger als 128 ist). Sie können wählen, ob Sie links inklusive oder links exklusiv und rechts inklusive oder rechts exklusiv sein möchten. Unabhängig von Ihrem gewählten Format können Sie davon ausgehen, dass alle Rechtecke mindestens 1x1 groß sind.

Anschließend zeichnen Sie jedes Rechteck auf dem Bildschirm (ASCII-Zeichenfläche) mit einem einzelnen Nicht-Leerzeichen k, das Sie auswählen können.

Wenn sich jedoch zwei Rechtecke überlappen, wird der überlappende Bereich mit einem anderen Nicht-Leerzeichen gezeichnet l != k, das Sie ebenfalls auswählen können.

Immer wenn sich drei Rechtecke überlappen, sollte der überlappende Bereich mit kund für eine ungerade Anzahl von bedeckenden Rechtecken kund eine gerade Anzahl gezeichnet werden l.

Der Hintergrund sollte aus einzelnen Leerzeichen bestehen ( 0x20).

Testfälle ( 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


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

Anmerkungen

• Führende Leerzeichen und Zeilenumbrüche (die auftreten, wenn die Mindestkoordinate nicht 0, 0vorhanden ist ) müssen vorhanden sein
• Nachgestellte Leerzeichen und Zeilenumbrüche sind in angemessenem Umfang zulässig (dh nicht wie 100000000 Zeilenumbrüche verfolgen, das ist nur ärgerlich).
• x- und y-Achsen können in beide Richtungen zeigen, aber Sie müssen konsistent sein und angeben, welche (Standard ist x-rechts und y-unten)
• Koordinaten können 0-, 1- oder 2-indiziert sein.

Referenz-Protonenimplementierung

Dies ist Code-Golf , daher ist das Ziel, den kürzesten Code zu haben. Viel Spaß beim Golfen!

6502 Maschinencode- Routine (C64), 57 Bytes

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

Dies ist positionsunabhängiger Code. Legen Sie ihn irgendwo im RAM ab und verwenden Sie die richtige Startadresse, mit der er aufgerufen wird sys.

Online-Demo (Startadresse$C000/49152).

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

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

Bei angemessenen Zahlenbereichen: Der natürliche Bereich auf dieser 8-Bit-Maschine ist [0-255], und das Programm akzeptiert dies als Parameter. Der C64-Bildschirm hat jedoch nur 40 Spalten und 25 Zeilen, wodurch der angemessene Bereich für x-Werte auf [0-40] und für y-Werte auf [0-25] begrenzt wird. Die Verwendung anderer Werte führt zu einem unvorhersehbaren Verhalten.

Kommentar zur Demontage:

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 Bytes

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)

Probieren Sie es online aus!

Holzkohle , 40 Bytes

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

Probieren Sie es online aus! Der Link führt zur ausführlichen Version des Codes. Wird 6 Byte kürzer sein, sobald @ ASCII-only einen Fehler in Charcoal behebt . Nimmt die Eingabe als eine durch Zeilenumbrüche abgeschlossene Liste von durch Leerzeichen getrennten Koordinatenlisten entgegen. Erläuterung:

ＷＳ«

Durchlaufen Sie jede Eingabezeile, bis eine leere Zeile erreicht ist.

≔Ｉ⪪ι ι

Teilen Sie die Zeile in eine Liste von Koordinaten.

Ｆ…§ι⁰§ι²«

Schleife über alle X-Koordinaten.

Ｊκ§ι¹

Springe zum Anfang der Spalte.

ＵＭ

Karte über ...

ＫＤ⁻§ι³§ι¹↓

... alle Zellen in der Spalte ...

§10Σλ

... der neue Wert ist, 0wenn sie etwas 1anderes enthalten 1. Bearbeiten: Kurz nach dem Schreiben hat Charcoal das Verhalten von ¬so geändert , dass Ｉ¬Σλhier 1 Byte gespeichert wird.

Python 2 , 181 Bytes

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

Probieren Sie es online aus!

C (gcc) , 205 Bytes

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

Probieren Sie es online aus!

R , 196 189 Bytes

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

Probieren Sie es online aus!

Der Code liest die Eingabe als stdin, angeordnet als x1 y1 x2 y2 Tupel, wobei x die Spalte und y die Zeile ist. Ich verwende 1 und 2 für die Überlappungsebenen, wobei 1 eine gerade Ebene darstellt.

7 Benutzer dank user2390246 gespeichert.

Raku , 54 Bytes

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

Probieren Sie es online aus!

Nimmt die Eingabe als flache Liste von Koordinaten als inklusive Koordinaten, dh x1,y1,x2,y2,x1,y1,x2,y2...und gibt sie als Liste der Liste von Zeichen mit kSein 1und lSein aus 0.

Erläuterung:

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

Gelee , 43 Bytes

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

Probieren Sie es online aus!

Erläuterung

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