Inclusion-Exclusion vous permet de calculer les tailles de certaines unions et intersections entre les ensembles en connaissant certaines des autres valeurs. Je ne l'expliquerai pas exactement, mais votre défi est de visualiser l'inclusion-exclusion sur un diagramme de Venn.

Parce que je suis sympa, vous utiliserez des rectangles, pas des cercles.

Vous recevrez une liste de rectangles indiqués par des coordonnées de coin en haut à gauche et en bas à droite dans n'importe quel format raisonnable (liste de 4 tuples, liste de paires de paires, liste de paires, etc.). Vous pouvez supposer que toutes les coordonnées ne sont pas négatives et se situent dans la plage de nombres (raisonnable) de votre langue (veuillez préciser de quoi il s'agit si elle est inférieure à 128). Vous pouvez choisir d'être inclusif à gauche ou exclusif à gauche et inclusif à droite ou exclusif à droite. Quel que soit le format choisi, vous pouvez supposer que tous les rectangles sont au moins 1x1.

Ensuite, vous devez dessiner chaque rectangle sur l'écran (canevas ASCII) en utilisant un seul caractère non blanc k, à vous de choisir.

Cependant, chaque fois que deux rectangles se chevauchent, la zone de chevauchement doit être dessinée avec un autre caractère non blanc l != k, également à vous de choisir.

Chaque fois que trois rectangles se chevauchent, la zone de chevauchement doit être établi avec k, et pour un nombre impair de rectangles de couverture, ket un nombre pair l.

L'arrière-plan doit être composé d'espaces simples ( 0x20).

Cas de test ( 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


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

Remarques

• Les espaces de début et les nouvelles lignes (qui se produisent si la coordonnée minimale n'est pas 0, 0) doivent être présents
• Tous les espaces de fin et les sauts de ligne sont autorisés dans une mesure raisonnable (c'est-à-dire ne traînent pas comme 100000000 sauts de ligne, c'est juste ennuyeux)
• Les axes x et y peuvent être orientés dans les deux sens, mais vous devez être cohérent et spécifier lequel (la valeur par défaut est x droite et y bas)
• les coordonnées peuvent être indexées de 0, 1 ou 2.

Implémentation de Proton de référence

C'est du code-golf , donc l'objectif est d'avoir le code le plus court. Bon golf!

6502 routine de code machine (C64), 57 octets

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

Il s'agit d'un code indépendant de la position, placez-le quelque part dans la RAM et utilisez la bonne adresse de début en l'appelant avec sys.

Démo en ligne (adresse de départ$C000/49152).

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

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

Sur des plages de nombres raisonnables: La plage naturelle sur cette machine 8 bits est [0-255], et le programme l'acceptera comme paramètres. Mais l'écran C64 n'a que 40 colonnes et 25 lignes, limitant ainsi la plage raisonnable à [0-40] pour les valeurs x et [0-25] pour les valeurs y. L'utilisation d'autres valeurs aura un comportement imprévisible.

Liste de démontage commentée:

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 189 185 158 154 147 147 octets

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)

Essayez-le en ligne!

Fusain , 40 octets

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. Sera 6 octets plus court une fois @ ASCII uniquement corrige un bug dans Charcoal . Prend l'entrée comme une liste terminée par une nouvelle ligne de liste de coordonnées séparées par des espaces. Explication:

ＷＳ«

Faites une boucle sur chaque ligne d'entrée jusqu'à ce qu'une ligne vierge soit atteinte.

≔Ｉ⪪ι ι

Divisez la ligne en une liste de coordonnées.

Ｆ…§ι⁰§ι²«

Faites une boucle sur toutes les coordonnées X.

Ｊκ§ι¹

Sautez en haut de la colonne.

ＵＭ

Carte sur chacun de ...

ＫＤ⁻§ι³§ι¹↓

... toutes les cellules de la colonne ...

§10Σλ

... la nouvelle valeur est 0s'ils contiennent 1, sinon 1. Edit: peu de temps après avoir écrit ceci, Charcoal a changé le comportement de ¬ce qui Ｉ¬Σλfonctionne ici pour économiser 1 octet.

Python 2 , 181 octets

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

Essayez-le en ligne!

C (gcc) , 205 octets

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

Essayez-le en ligne!

R , 196 189 octets

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

Essayez-le en ligne!

Le code lit l'entrée comme stdin, arrangé comme un tuple x1 y1 x2 y2, où x est la colonne et y est la ligne. J'utilise 1 et 2 pour les niveaux de chevauchement, où 1 représente un niveau pair.

Enregistré 7 octets grâce à user2390246.

Raku , 54 octets

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

Essayez-le en ligne!

Prend les entrées sous forme de liste plate de coordonnées sous forme de coordonnées inclusives, c'est x1,y1,x2,y2,x1,y1,x2,y2...-à- dire et les sorties sous forme de liste de caractères avec l' kêtre 1et l' lêtre 0.

Explication:

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

Gelée , 43 octets

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

Essayez-le en ligne!

Explication

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