Après vous être réveillé dans une pièce sombre, vous voyez une grille rectangulaire de lumières avec des interrupteurs correspondants. Vous décidez d'utiliser un système de coordonnées avec la lumière en bas à gauche représentant (1,1) et les coordonnées augmentant à mesure que vous montez (direction y) et vers la droite (direction x). Les grilles sont identiques en ce que le basculement de l'interrupteur sur (a, b) bascule (passe de éteint à allumé ou de allumé à éteint) la lumière à (a, b) ainsi que les lumières dans la même colonne ou la même rangée que ( un B).

Votre entrée sera une grille rectangulaire de deux caractères distincts représentant on et off (j'utilise 1 et 0, respectivement). En outre, une partie de l'entrée sera une série d'au moins une paire de coordonnées (avec le format et la séparation que vous souhaitez) qui représentera les commutateurs que vous inverserez.

La sortie sera la même grille, avec le "flip" appliqué à chacune des paires de coordonnées qui ont été données en entrée. Vous pouvez choisir comment formater votre entrée, bien que la sortie doive être une grille, pas un tableau.

Échantillons

Exemple d'entrée 1

111111
111111
111111
111111

(3,2)

Exemple de sortie 1

110111
110111
000000
110111

Exemple d'entrée 2

01101
10100
00010
11111
10110

(1,1), (5,5)

Exemple de sortie 2

00010
00101
10011
01110
01000

Exemple d'entrée 3

1

(1,1)

Exemple de sortie 3

0

Exemple d'entrée 4

00000
11111
00000
11111

(2,3), (2,3)

Exemple de sortie 4

00000
11111
00000
11111

C'est le golf de code. Des règles standard s'appliquent. Le code le plus court en octets gagne.

CJam, 37 36 octets

qN/W%(~{1$::!\{1a\Te[f.|z}/..^}/W%N*

L'entrée doit avoir la grille en premier, en utilisant deux caractères non NULL qui ne diffèrent que dans le dernier bit (donc 0et 1fonctionnent), suivis d'une liste de paires de coordonnées de style CJam.

01101
10100
00010
11111
10110
[[1 1] [5 5]]

Testez-le ici.

Dyalog APL, 20 octets

{⍵≠⊃⊃≠/∘.∨/¨⍺=⊂⍳¨⍴⍵}

Il s'agit d'une fonction dyadique qui prend la grille initiale à droite et la liste des coordonnées à gauche.

Pour entrer une seule paire de coordonnées, utilisez par exemple (⊂2 3)comme argument de gauche.

Essayez-le ici .

MATL , 39 octets

i,-1H$X!tyZ}:XJx:!XIxi"I@1)=J@2)=|+]2\X!

L'entrée est de la forme suivante (l'exemple correspond à l'exemple d'entrée 2 dans le défi):

[0 1 1 0 1; 1 0 1 0 0; 0 0 0 1 0; 1 1 1 1 1; 1 0 1 1 0]  
[1 5; 1 5]

La première entrée est une matrice définissant la grille de 0et 1. ;est le séparateur de lignes. La deuxième entrée est une matrice de paires de coordonnées, où chaque colonne est une paire.

Exemple

>> matl i1_2$X!tyZ}:XJx:!XIxi"I@1)=J@2)=|+]2\X!
> [0 1 1 0 1; 1 0 1 0 0; 0 0 0 1 0; 1 1 1 1 1; 1 0 1 1 0]
> [1 5; 1 5]
0 0 0 1 0
0 0 1 0 1
1 0 0 1 1
0 1 1 1 0
0 1 0 0 0

Explication

i,           % input matrix
-1H$X!       % rotate clockwise to accomodate input to matrix coordinates
tyZ}         % get numbers of rows (r) and of cols (c)
:XJx         % row vector 1,2,,...,c. Copy to clipboard J and delete
:!XIx        % col vector 1,2,,...,r. Copy to clipboard I and delete
i            % input coordinates (matrix; each col is a coordinate)
"            % for each col of coordinate matrix
    I@1)=    % compare col vector of rows with row from coordinate
    J@2)=    % compare row vector of cols with col from coordinate
    |        % "or" with singleton expansion to generate mask
    +        % add that to matrix of values
]            % end for
2\           % modulo 2 to transform result into zeros and ones
X!           % undo rotation

Ruby 114 octets

Prend en entrée:

g, un tableau de tableaux représentant la grille de départ.

o, un tableau de points, chaque point étant un tableau à deux éléments, comme [x, y].

->g,o{o.map{|i|(r=g[i[1]-1])[e=(i[0]-1)]-=1;r.map!{|j|j+1};g.map{|x|x[e]+=1}};puts g.map{|i|i.map{|j|j%2}.join""}}