O código mais curto para passar todas as possibilidades ganha

Muitos jogos baseados em grade foram criados que começam com uma grade de luzes acesas. Pressionar qualquer uma das luzes faz com que essa luz e as quatro luzes adjacentes sejam alternadas. Quando uma luz é alternada, ela é desligada ou ligada, dependendo se foi ativada ou desativada. O objetivo é acertar as luzes em uma sequência que resulta no desligamento de todas as luzes no final.

"X" representa luzes acesas. "O" representa luzes que estão desligadas. "P" representa o quadrado pressionado.

XOO          XOO      XOX      XOX      XXX
XOX          XOP  ->  XXO  ->  OPO  ->  XOX
OOX          OOX      POO      XXO      XOO

Intial Grid  Press 1  Press 2  Press 3  Ending Grid

A entrada pode ser obtida diretamente de um arquivo passado como argumento ou como entrada padrão. A primeira linha de entrada conterá x (1 <= x <= 20), o tamanho da grade de luzes, ou seja, x por x . A segunda linha conterá y (0 <= y <= ( x * 3) ² ), o número de luzes inicialmente acesas. As próximas linhas y contêm coordenadas de luzes acesas na grade, no formato de "coluna de linha". As luzes que já estão acesas (foram alternadas anteriormente) devem ser apagadas novamente. A próxima linha conterá z , o número de luzes pressionadas. O z final as linhas contêm coordenadas das luzes pressionadas, na ordem em que foram pressionadas, no formato de "coluna de linha".

Nenhuma entrada estará incorreta. Todos os números estarão dentro dos limites especificados da grade.

A saída será a grade final após todas as luzes terem sido trocadas. Deve ser um n por n grid. Para cada área com uma luz acesa, deve ser usado o caractere maiúsculo "X". Para cada área com luz apagada, o caractere maiúsculo "O" deve ser usado.

As luzes afetadas que estão fora da grade devem ser ignoradas. Alternar uma luz na borda de uma grade deve afetar apenas as luzes que estão na própria grade.

Casos de teste

Entrada

4
5
2 3
2 4
3 1
3 4
4 3
7
3 3
4 4
3 4
4 2
4 1
2 2
3 2

Resultado

OXOO
XOXO
XOXO
OXOO

Entrada

1
3
1 1
1 1
1 1
2
1 1
1 1

Resultado

X

J, 132

'x f'=:0 2{,i=:".;._2(1!:1)3
echo u:79+9*}:"1}."1}.}:2|+/(1:`[`]}&(0$~,~x+2))"0<"1(f{.2}.i),;([:<[,[:|:(2 4$0 0,,~1 _1)+])"1(3+f)}.i

Provavelmente pode ser jogado muito mais longe.

• Somente console, stdin-> stdout. Testado no j602 no Linux.
• Passa nos dois testes fornecidos.
• Assume o limite superior são em X (sem precisão estendida)

Versão original não destruída:

NB. Whole input as two column grid
i=:".;._2(1!:1)3 

NB. x is x, f is number of initial toggles
'x f'=:0 2{,i 

NB. z is 1..x
z =: >:i.x 

NB. Take a boxed pair of indices, generate 'cross' indices (boxed)
f2=:3 :'y,,<"1(>y)+"1>0 1;1 0;0 _1;_1 0' 

NB. List of initial toggles, individually boxed
init=: <"1 f {. 2 }. i

NB. List of Ps, individually boxed
toggle=: <"1 (3 + f) }. i

NB. Grid of 0s padded on all sides
g =:0$~(x+2),(x+2)

NB. For each initial toggle, make a grid with a 1 in that position. Sum each 'position'.
grid =: +/ (1:`[`]}&g)"0 init

NB. For each position in the cross (f2) of each press, make a grid with a 1 in that position.
NB. Sum each 'position', add to 'grid', take mod 2, and select inner rows/columns.
gfinal =: z {"1 z { 2|grid + +/ (1:`([:f2[)`]}&g)"0 toggle

NB. Translate 0/1 to O/X through ascii and print
echo u:79+9*gfinal

Pitão, 209 203 199 caracteres

I=input
x=I()+1
s=0
C=lambda:eval(raw_input().replace(' ','*%d+'%x))
exec's^=1<<C();'*I()
exec's^=1+(7<<x)/2+(1<<x<<x)<<(C()-x);'*I()
R=range(1,x)
for r in R:print''.join('OX'[s>>r*x+c&1]for c in R)

O estado das luzes é mantido em uma única variável (grande) inteira s,. XORs com máscaras de bits são usados ​​para alternar as luzes. Eu mantenho um pouco mais por linha para evitar envolvimentos.

Ruby 1.9, 167 caracteres

n=gets.to_i
y=z=[*[1]*n,0]*n
$<.map{|i|a,b=i.split.map &:to_i;b ?[*y&&[b>1&&-1,b<n&&1,a>1&&~n,a<n&&n+1],0].map{|f|f&&z[n*a+a-n-2+b+f]*=-1}:y=!y}
z.map{|a|putc"
OX"[a]}

Editar% s:

• (198 -> 191) Removido algumas coisas desnecessárias
• (191 -> 180) Simplificado a maneira como a entrada é analisada
• (180 -> 172) Parênteses removidos, use em z[u]*=-1vez dez[u]=-z[u] , remova a variável não utilizada
• (172 -> 169) Algumas simplificações
• (169 -> 167) Simplificado um condicional

Perl, 139 caracteres

@s=1..<>;<>=~/ /,$f{$`,$'+0}=1for 1..<>;<>=~/ /,map$f{$`+$_*($_&1),$'+int$_/2}^=1,-2..2for 1..<>;$\=$/;for$x(@s){print map$f{$x,$_}?X:O,@s}

Explicação:

# Read size and generate an array of integers from 1 to the size.
# We’ll need to iterate over this array often, but otherwise we don’t need the size
@s = 1..<>;

# Read number of prelit lights
for (1..<>) {
    # Find the space; sets $` and $' to row and column, respectively
    <> =~ / /;
    # Set the relevant light; need +0 because $' includes the newline
    $f{$`, $'+0} = 1;
}

# Read number of light switchings
for (1..<>) {
    # As above
    <> =~ / /;
    # Some nice formulas that flip the 5 relevant lights,
    # including the ones “off the board”, but we don’t care about those
    map {
        $f{ $`+$_*($_&1), $'+int$_/2 } ^= 1
    }, (-2..2);
}

# Cause each subsequent print statement to print a newline after it
$\ = $/;

# For each row...
for $x (@s) {
    # Print X’s and O’s as required
    print map { $f{$x,$_} ? X : O }, @s;
}

APL (71)

'OX'[1+⊃{⍵≠(⍳⍴⍵)∊(⊂⍺)+K,⌽¨K←(0 1)(0 0)(0 ¯1)}/({⎕}¨⍳⎕),⊂({⎕}¨⍳⎕)∊⍨⍳2/⎕]