Depois de acordar em um quarto escuro, você vê uma grade retangular de luzes com os interruptores correspondentes. Você decide usar um sistema de coordenadas com a luz inferior esquerda representando (1,1) e as coordenadas aumentando à medida que você sobe (direção y) e para a direita (direção x). As grades são idênticas, ao acionar o interruptor em (a, b) alterna (desliga de ligado para ligado ou desligado) a luz em (a, b), bem como as luzes na mesma coluna ou na mesma linha que ( a, b)

Sua entrada será uma grade retangular de dois caracteres distintos, representando ativado e desativado (eu uso 1 e 0, respectivamente). Além disso, uma parte da entrada será uma série de pelo menos um par de coordenadas (com o formato e a separação desejados) que representará as opções que você inverte.

A saída será a mesma grade, com o "flip" aplicado em cada um dos pares de coordenadas que foram dados como entrada. Você pode escolher como formatar sua entrada, embora a saída deva ser uma grade, não uma matriz.

Amostras

Entrada de amostra 1

111111
111111
111111
111111

(3,2)

Saída de amostra 1

110111
110111
000000
110111

Entrada de amostra 2

01101
10100
00010
11111
10110

(1,1), (5,5)

Saída de amostra 2

00010
00101
10011
01110
01000

Entrada de amostra 3

1

(1,1)

Saída de amostra 3

0

Entrada de amostra 4

00000
11111
00000
11111

(2,3), (2,3)

Saída de amostra 4

00000
11111
00000
11111

Isso é código de golfe. Aplicam-se regras padrão. O menor código em bytes vence.

CJam, 37 36 bytes

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

A entrada deve ter a grade primeiro, usando dois caracteres não NULL que diferem apenas no último bit (so 0e 1work), seguido por uma lista de pares de coordenadas no estilo CJam.

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

Teste aqui.

Dyalog APL, 20 bytes

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

Esta é uma função diádica que pega a grade inicial à direita e a lista de coordenadas à esquerda.

Para inserir um único par de coordenadas, use, por exemplo, (⊂2 3)como argumento à esquerda.

Experimente aqui .

MATL , 39 bytes

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

A entrada é do seguinte formato (o exemplo corresponde à entrada de amostra 2 no desafio):

[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]

A primeira entrada é uma matriz que define a grade de 0e 1. ;é o separador de linhas. A segunda entrada é uma matriz de pares de coordenadas, em que cada coluna é um par.

Exemplo

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

Explicação

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 bytes

Toma como entrada:

g, uma matriz de matrizes representando a grade inicial.

o, uma matriz de pontos, cada ponto sendo uma matriz com dois elementos, como [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""}}