Inclusión-Exclusión le permite calcular los tamaños de algunas uniones e intersecciones entre conjuntos conociendo algunos de los otros valores. No lo explicaré exactamente, pero su desafío es visualizar la inclusión-exclusión en un diagrama de Venn.

Como soy amable, usarás rectángulos, no círculos.

Se le dará una lista de rectángulos indicados por las coordenadas de la esquina superior izquierda e inferior derecha en cualquier formato razonable (lista de 4 tuplas, lista de pares de pares, lista de pares, etc.). Puede suponer que todas las coordenadas no son negativas y están dentro del rango de números (razonable) de su idioma (especifique qué es si es menor que 128). Puede elegir ser inclusivo a la izquierda o exclusivo a la izquierda e inclusivo a la derecha o exclusivo a la derecha. Independientemente del formato elegido, puede asumir que todos los rectángulos son al menos 1x1.

Luego, debe dibujar cada rectángulo en la pantalla (lienzo ASCII) utilizando un único carácter que no sea un espacio en blanco k, que puede elegir.

Sin embargo, cada vez que se superpongan dos rectángulos, el área superpuesta se dibujará con otro carácter que no sea un espacio en blanco l != k, también el suyo para elegir.

Siempre que tres rectángulos se superponen, el área de superposición debe ser dibujado con k, y por un número impar de rectángulos que cubre, ky un número par, l.

El fondo debe ser espacios en blanco individuales ( 0x20).

Casos de prueba ( 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


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

Notas

• Los espacios iniciales y las nuevas líneas (que ocurren si la coordenada mínima no lo está 0, 0) deben estar presentes
• Todos los espacios finales y las nuevas líneas están permitidos en un grado razonable (es decir, no sigas como 100000000 nuevas líneas, eso es molesto)
• los ejes x e y pueden estar orientados en ambos sentidos, pero debe ser coherente y especificar cuál (el valor predeterminado es x-right e y- down)
• Las coordenadas pueden ser 0-, 1- o 2- indexadas.

Implementación de protones de referencia

Este es el código de golf , por lo que el objetivo es tener el código más corto. ¡Feliz golf!

6502 rutina de código de máquina (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

Este es un código independiente de la posición, colóquelo en algún lugar de la RAM y use la dirección de inicio correcta para llamarlo sys.

Demostración en línea (dirección de inicio$C000/49152).

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

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

En rangos de números razonables: el rango natural en esta máquina de 8 bits es [0-255], y el programa aceptará esto como parámetros. Pero la pantalla C64 solo tiene 40 columnas y 25 filas, por lo tanto, limita el rango razonable a [0-40] para valores de x y [0-25] para valores de y. El uso de otros valores tendrá un comportamiento impredecible.

listado de desmontaje comentado:

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)

Pruébalo en línea!

Carbón , 40 bytes.

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

Pruébalo en línea! El enlace es a la versión detallada del código. Será 6 bytes más corto una vez que @ ASCII solo corrige un error en Charcoal . Toma datos como una lista terminada en nueva línea de una lista de coordenadas separadas por espacios. Explicación:

ＷＳ«

Pase cada línea de entrada hasta llegar a una línea en blanco.

≔Ｉ⪪ι ι

Divida la línea en una lista de coordenadas.

Ｆ…§ι⁰§ι²«

Recorre todas las coordenadas X.

Ｊκ§ι¹

Salta a la parte superior de la columna.

ＵＭ

Mapa sobre cada uno de ...

ＫＤ⁻§ι³§ι¹↓

... todas las celdas de la columna ...

§10Σλ

... el nuevo valor es 0si contienen 1, de lo contrario 1. Editar: poco después de escribir esto, el carbón cambió el comportamiento de ¬modo que Ｉ¬Σλfunciona aquí para guardar 1 byte.

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

Pruébalo en línea!

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

Pruébalo en línea!

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

Pruébalo en línea!

El código lee la entrada como stdin, organizada como una tupla x1 y1 x2 y2, donde x es la columna e y es la fila. Estoy usando 1 y 2 para los niveles de superposición, donde 1 representa un nivel par.

Guardado 7 bytes gracias a user2390246.

Raku , 54 bytes

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

Pruébalo en línea!

Toma la entrada como una lista plana de coordenadas como coordenadas inclusivas, es decir, x1,y1,x2,y2,x1,y1,x2,y2...y las salidas como una lista de la lista de caracteres con kbeing 1y lbeing 0.

Explicación:

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

Jalea , 43 bytes

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

Pruébalo en línea!

Explicación

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