Visualizza Inclusion-Exclusion

11

Inclusion-Exclusion consente di calcolare le dimensioni di alcuni sindacati e intersezioni tra insiemi conoscendo alcuni degli altri valori. Non lo spiegherò esattamente, ma la tua sfida è quella di visualizzare l'inclusione-esclusione su un diagramma di Venn.

Perché sono gentile, userete rettangoli, non cerchi.

Ti verrà dato un elenco di rettangoli indicati dalle coordinate degli angoli in alto a sinistra e in basso a destra in qualsiasi formato ragionevole (elenco di 4 tuple, elenco di coppie di coppie, elenco di coppie, ecc.). Puoi presumere che tutte le coordinate non siano negative e rientrino nell'intervallo di numeri (ragionevole) della tua lingua (specifica di cosa si tratta se è inferiore a 128). Puoi scegliere di essere inclusivo di sinistra o esclusivo di sinistra e inclusivo di destra o esclusivo di destra. Indipendentemente dal formato scelto, puoi presumere che tutti i rettangoli siano almeno 1x1.

Quindi, devi disegnare ogni rettangolo sullo schermo (tela ASCII) usando un singolo carattere non bianco k, a tua scelta.

Tuttavia, ogni volta che due rettangoli si sovrappongono, l'area di sovrapposizione deve essere disegnata con un altro carattere non bianco l != k, anche il tuo da scegliere.

Ogni volta tre rettangoli sovrappongono, l'area di sovrapposizione dovrebbe essere disegnata k, e per un numero dispari di rettangoli copertura, ke un numero pari, l.

Lo sfondo dovrebbe essere single whitespace ( 0x20).

Casi di prova ( 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


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

Appunti

  • Spazi iniziali e newline (che si verificano se la coordinata minima non è 0, 0) devono essere presenti
  • Tutti gli spazi finali e le nuove righe sono consentiti in misura ragionevole (cioè non trascinare come 100000000 newline, è solo fastidioso)
  • gli assi x e y possono essere rivolti in entrambi i modi, ma è necessario essere coerenti e specificare quali (il valore predefinito è x-right e y-down)
  • le coordinate possono essere indicizzate 0, 1 o 2.

Implementazione Proton di riferimento

Questo è code-golf , quindi l'obiettivo è quello di avere il codice più corto. Buon golf!

code-golf  ascii-art 
— HyperNeutrino
fonte
l'asse x si estende verso destra e l'asse y si estende verso il basso dall'angolo in alto a sinistra?
— user202729,
@ user202729 In casi di test, sì (in realtà ambiguo) ma è possibile utilizzarli a condizione che siano coerenti
— HyperNeutrino,
@dzaima Yup. [...]
— HyperNeutrino,
1
@JoKing sì, renderò il formato di input più flessibile. ho capito che si trattava di una vecchia sfida e non avevo ancora familiarità con la scrittura della sfida
— HyperNeutrino il
1
@JoKing In realtà permetterò una qualsiasi delle quattro combinazioni.
— HyperNeutrino il

Risposte:

4

6502 routine codice macchina (C64), 57 byte

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

Questo è un codice indipendente dalla posizione, mettilo da qualche parte nella RAM e usa l'indirizzo iniziale corretto chiamandolo con sys.

Demo online (indirizzo iniziale$C000/49152).

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

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

Su intervalli di numeri ragionevoli: l'intervallo naturale su questa macchina a 8 bit è [0-255] e il programma lo accetterà come parametri. Ma lo schermo C64 ha solo 40 colonne e 25 righe, limitando quindi l' intervallo ragionevole a [0-40] per i valori x e [0-25] per i valori y. L'uso di altri valori avrà un comportamento imprevedibile.

elenco di smontaggio commentato:

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
— Felix Palmen
fonte
3

Python 2 , 218 192 189 185 158 154 147 byte

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)

Provalo online!

— TFeld
fonte
3

Carbone , 40 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Sarà più breve di 6 byte una volta che @ ASCII risolve solo un bug in Charcoal . Accetta input come un elenco terminato di nuova riga di un elenco di coordinate separato da spazi. Spiegazione:

ＷＳ«

Scorri su ogni riga di input fino a quando non viene raggiunta una riga vuota.

≔Ｉ⪪ι ι

Dividi la linea in un elenco di coordinate.

Ｆ…§ι⁰§ι²«

Passa sopra tutte le coordinate X.

Ｊκ§ι¹

Vai all'inizio della colonna.

ＵＭ

Mappa su ciascuno dei ...

ＫＤ⁻§ι³§ι¹↓

... tutte le celle nella colonna ...

§10Σλ

... il nuovo valore è 0se contengono 1, altrimenti 1. Modifica: Poco dopo aver scritto questo, Charcoal ha cambiato il comportamento di ¬così che Ｉ¬Σλfunziona qui per salvare 1 byte.

— Neil
fonte
: | ho rovinato
— ASCII il
@ Bug solo ASCII nella mia soluzione alternativa - Posso stampare un \ninvece immagino ...
— Neil,
2

Python 2 , 181 byte

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

Provalo online!

— asta
fonte
2

C (gcc) , 205 byte

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

Provalo online!

— Felix Palmen
fonte
2

R , 196 189 byte

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

Provalo online!

Il codice legge l'input come stdin, organizzato come una tupla x1 y1 x2 y2, dove x è la colonna e y è la riga. Sto usando 1 e 2 per i livelli di sovrapposizione, dove 1 rappresenta un livello uniforme.

7 byte salvati grazie all'utente2390246.

— NOFP
fonte
1
Alcune idee per giocare a golf: 1. C'è bisogno di trasformare la tua matrice x? 2. Usa nrow(o ncolse non trasformato) invece di dim(x)[1]3. Non è necessario definire i=y>0come lo usi solo una volta.
— user2390246,
4. Inizializza la matrice su -1 e poi usa solo y=y%%2e y[y<0]=" ".
— user2390246,
Grazie. Ho incluso i suggerimenti 1 e 2. I suggerimenti 3 e 4 non funzionerebbero perché: i = y> 0 viene utilizzato per memorizzare i livelli prima dell'applicazione del modulo e il modulo non deve conservare i segni. Tuttavia, ciò mi ha dato l'idea di utilizzare la convenzione R implicita che 0 = FALSO e di salvare due byte extra. :)
— NofP,
2

Raku , 54 byte

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

Provalo online!

Prende input come un elenco piatto di coordinate come coordinate inclusive, ovvero x1,y1,x2,y2,x1,y1,x2,y2...e output come un elenco di elenchi di caratteri con kessere 1e lessere 0.

Spiegazione:

{                                                    }  # 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
— Jo King
fonte
1

Gelatina , 43 byte

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

Provalo online!

Spiegazione

+µ>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)
— HyperNeutrino
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.