Inclusão-Exclusão permite calcular os tamanhos de algumas uniões e interseções entre conjuntos, conhecendo alguns dos outros valores. Não vou explicar exatamente, mas seu desafio é visualizar a inclusão-exclusão em um diagrama de Venn.

Porque eu sou legal, você estará usando retângulos, não círculos.

Você receberá uma lista de retângulos indicados pelas coordenadas do canto superior esquerdo e inferior direito em qualquer formato razoável (lista de 4 tuplas, lista de pares de pares, lista de pares, etc.). Você pode assumir que todas as coordenadas são não-negativas e estão dentro do intervalo de números (razoável) do seu idioma (especifique o que é se for menor que 128). Você pode optar por ser inclusivo à esquerda ou exclusivo à esquerda e inclusivo à direita ou exclusivo à direita. Independentemente do formato escolhido, você pode assumir que todos os retângulos são pelo menos 1x1.

Em seguida, você deve desenhar cada retângulo na tela (tela ASCII) usando um único caractere kque não seja um espaço em branco , que você poderá escolher.

No entanto, sempre que dois retângulos se sobrepõem, a área sobreposta deve ser desenhada com outro caractere que não seja um espaço em branco l != k, também seu para você escolher.

Sempre que três retângulos se sobrepõem, a área sobreposta deve ser desenhada com ke para um número ímpar de retângulos que cobrem k, e um número par l.

O plano de fundo deve ser um espaço em branco único ( 0x20).

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

• Espaços iniciais e novas linhas (que ocorrem se a coordenada mínima não estiver 0, 0) devem estar presentes
• Quaisquer espaços à direita e novas linhas são permitidos em uma extensão razoável (ou seja, não rastreie como 100000000 novas linhas, isso é apenas irritante)
• os eixos xe y podem ficar virados para os dois lados, mas você deve ser consistente e especificar quais (o padrão é x-right e y-down)
• as coordenadas podem ser indexadas em 0, 1 ou 2.

Implementação de referência de prótons

Isso é código-golfe , então o objetivo é ter o código mais curto. Feliz golfe!

Rotina de código de máquina 6502 (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 é um código independente da posição, coloque-o em algum lugar da RAM e use o endereço inicial correto para chamá-lo sys.

Demonstração online (endereço inicial$C000/49152).

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

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

Em faixas de número razoáveis: A faixa natural nesta máquina de 8 bits é [0-255] e o programa aceitará isso como parâmetros. Mas a tela C64 possui apenas 40 colunas e 25 linhas, limitando, portanto, o intervalo razoável a [0-40] para valores x e [0-25] para valores y. O uso de outros valores terá um comportamento imprevisível.

lista de desmontagem comentada:

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)

Experimente online!

Carvão , 40 bytes

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

Experimente online! Link é a versão detalhada do código. Será 6 bytes mais curto quando o ASCII corrigir apenas um bug no Charcoal . Recebe entrada como uma lista terminada por nova linha de lista de coordenadas separadas por espaço. Explicação:

ＷＳ«

Faça um loop sobre cada linha de entrada até que uma linha em branco seja alcançada.

≔Ｉ⪪ι ι

Divida a linha em uma lista de coordenadas.

Ｆ…§ι⁰§ι²«

Faça um loop sobre todas as coordenadas X.

Ｊκ§ι¹

Salte para o topo da coluna.

ＵＭ

Mapa sobre cada ...

ＫＤ⁻§ι³§ι¹↓

... todas as células da coluna ...

§10Σλ

... o novo valor é 0se eles contiverem 1, caso contrário 1. Edit: Logo depois de escrever isso, o carvão mudou o comportamento de ¬modo que Ｉ¬Σλfunciona aqui para economizar 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))

Experimente online!

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

Experimente online!

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

Experimente online!

O código lê a entrada como stdin, organizada como uma tupla x1 y1 x2 y2, onde x é a coluna e y é a linha. Estou usando 1 e 2 para os níveis de sobreposição, onde 1 representa um nível par.

Economizado 7 bytes graças a user2390246.

Raku , 54 bytes

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

Experimente online!

Recebe entrada como uma lista simples de coordenadas como coordenadas inclusivas, ou seja, x1,y1,x2,y2,x1,y1,x2,y2...e gera como uma lista de lista de caracteres com kser 1e lser 0.

Explicação:

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

Gelatina , 43 bytes

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

Experimente online!

Explicação

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