포함-제외를 사용하면 다른 값 중 일부를 알고있는 집합 간의 교집합과 교집합의 크기를 계산할 수 있습니다. 나는 그것을 정확하게 설명하지는 않지만, 당신의 도전은 벤 다이어그램에서 포함 제외를 시각화하는 것입니다.

내가 좋기 때문에 원이 아닌 사각형을 사용하게됩니다.

합리적인 형식으로 왼쪽 상단 및 오른쪽 하단 모서리 좌표로 표시되는 사각형 목록이 제공됩니다 (4 개의 튜플 목록, 페어 쌍 목록, 페어 목록 등). 모든 좌표가 음이 아니며 언어의 (합리적인) 숫자 범위 내에 있다고 가정 할 수 있습니다 (128보다 작은 경우의 값을 지정하십시오). 왼쪽 포함 또는 왼쪽 독점 및 오른쪽 포함 또는 오른쪽 독점 중에서 선택할 수 있습니다. 선택한 형식에 관계없이 모든 사각형이 1x1 이상이라고 가정 할 수 있습니다.

그런 다음 공백이 아닌 단일 문자를 사용하여 화면의 각 사각형 (ASCII 캔버스)을 그려야 k합니다.

그러나 두 개의 사각형이 겹칠 때마다 겹치는 영역은 공백이 아닌 다른 문자와 함께 l != k선택해야합니다.

마다 세 개의 사각형이 중첩 영역이 중첩에 그려 져야 k하고, 덮는 직사각형의 홀수 번호 k, 및 짝수 l.

배경은 단일 공백 ​​( 0x20) 이어야합니다 .

테스트 사례 ( 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


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

메모

• 선행 공백과 줄 바꿈 (최소 좌표가 아닌 경우 발생 0, 0)이 있어야합니다.
• 후행 공백과 줄 바꿈은 합리적으로 허용됩니다 (즉, 100000000 줄 바꿈처럼 트레일하지 마십시오.
• x 축과 y 축은 어느 쪽이든 향할 수 있지만 일관되고 일관성이 있어야합니다 (기본값은 x와 오른쪽).
• 좌표는 0, 1 또는 2 색인이 될 수 있습니다.

참조 양성자 구현

이것은 code-golf 이므로 목표는 가장 짧은 코드를 갖는 것입니다. 행복한 골프!

6502 머신 코드 루틴 (C64), 57 바이트

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

이것은 위치 독립적 인 코드이며 RAM 어딘가에 넣고로 시작하는 올바른 시작 주소를 사용하십시오 sys.

온라인 데모 (시작 주소$C000/49152).

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

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

합리적인 수 범위 :이 8 비트 시스템의 자연 범위는 [0-255]이며 프로그램은이 값을 매개 변수로 허용합니다. 그러나 C64 화면에는 40 개의 열과 25 개의 행만 있으므로 x 범위의 경우 적절한 범위를 [0-40], y 값의 경우 [0-25]로 제한합니다. 다른 값을 사용하면 예기치 않은 동작이 발생합니다.

주석 처리 된 해체 목록 :

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

파이썬 (2) , 218 (192) 189 185 158 154 147 바이트

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)

온라인으로 사용해보십시오!

숯 , 40 바이트

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

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. @ASCII 전용이 Charcoal의 버그를 수정하면 6 바이트가 짧아집니다 . 공백으로 구분 된 좌표 목록의 개행으로 끝나는 목록으로 입력을받습니다. 설명:

ＷＳ«

빈 줄에 도달 할 때까지 각 입력 줄을 반복합니다.

≔Ｉ⪪ι ι

선을 좌표 목록으로 분할하십시오.

Ｆ…§ι⁰§ι²«

모든 X 좌표를 반복합니다.

Ｊκ§ι¹

열의 맨 위로 이동하십시오.

ＵＭ

각각의지도 ...

ＫＤ⁻§ι³§ι¹↓

... 열의 모든 세포 ...

§10Σλ

... 새로운 가치는 0그것들을 포함한다면 1, 그렇지 않으면 1. 편집 : 곧이 글을 쓰는 한 후, 카본의 행동 변화 ¬즉 있도록 Ｉ¬Σλ1 바이트를 저장하려면 여기를 작동합니다.

파이썬 2 , 181 바이트

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

온라인으로 사용해보십시오!

C (gcc) , 205 바이트

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

온라인으로 사용해보십시오!

R , 196 189 바이트

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

온라인으로 사용해보십시오!

이 코드는 x1 y1 x2 y2 튜플로 배열 된 입력을 표준 입력으로 읽습니다. 여기서 x는 열이고 y는 행입니다. 오버랩 레벨에 1과 2를 사용하고 있습니다. 여기서 1은 짝수 레벨을 나타냅니다.

user2390246 덕분에 7 바이트가 절약되었습니다.

라쿠 , 54 바이트

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

온라인으로 사용해보십시오!

즉 포함한 좌표로서 좌표 평면리스트로의 입력을 받아 x1,y1,x2,y2,x1,y1,x2,y2...가진 자리스트의리스트로서 출력한다 k인 1및 l인 0.

설명:

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

젤리 , 43 바이트

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

온라인으로 사용해보십시오!

설명

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