El código más corto para pasar todas las posibilidades gana

Se han hecho muchos juegos basados ​​en la red que comienzan con una red de luces que están encendidas. Al presionar cualquiera de las luces, se activa y se encienden las cuatro luces adyacentes. Cuando se enciende una luz, se apaga o se enciende, dependiendo de si se encendió o apagó inicialmente. El objetivo es encender las luces en una secuencia que da como resultado que todas las luces se apaguen al final.

"X" representa las luces que están encendidas. "O" representa las luces que están apagadas. "P" representa ese cuadrado que se presiona.

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

La entrada puede tomarse directamente de un archivo pasado como argumento o como entrada estándar. La primera línea de entrada contendrá x (1 <= x <= 20), el tamaño de la cuadrícula de luces, lo que significa x por x . La segunda línea contendrá y (0 <= y <= ( x * 3) ² ), el número de luces inicialmente encendidas. Las siguientes líneas y contienen coordenadas de luces encendidas en la cuadrícula, en el formato de "columna de fila". Las luces que ya están encendidas (se han activado previamente) deben desactivarse nuevamente. La siguiente línea contendrá z , el número de luces presionadas. La z final las líneas contienen coordenadas de las luces presionadas, en el orden en que fueron presionadas, en el formato de "columna de fila".

Ninguna entrada será incorrecta. Todos los números estarán dentro de los límites dados de la cuadrícula.

La salida será la grilla final después de que se hayan activado todas las luces. Debería ser una cuadrícula n por n . Para cada área que tiene una luz encendida, se debe usar el carácter en mayúscula "X". Para cada área que tiene una luz apagada, se debe usar el carácter en mayúscula "O".

Las luces afectadas que están fuera de la red deben ignorarse. Alternar una luz en el borde de una cuadrícula solo debería afectar las luces que se encuentran en la propia cuadrícula.

Casos de prueba

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

Salida

OXOO
XOXO
XOXO
OXOO

Entrada

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

Salida

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

Probablemente se pueda jugar mucho más al golf.

• Solo consola, stdin-> stdout. Probado en j602 en Linux.
• Pasa ambas pruebas dadas.
• Asume un límite superior sensato en X (sin precisión extendida)

Versión original sin golf:

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ón, 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)

El estado de las luces se mantiene en una sola (grande) variable entera, s. Los XOR con máscaras de bits se utilizan para alternar las luces. Mantengo un bit extra por fila para evitar la envoltura.

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

Ediciones:

• (198 -> 191) Se eliminaron algunas cosas innecesarias
• (191 -> 180) Simplificó la forma en que se analiza la entrada
• (180 -> 172) Paréntesis eliminados, use en z[u]*=-1lugar de z[u]=-z[u], quite la variable no utilizada
• (172 -> 169) Algunas simplificaciones
• (169 -> 167) Simplificado un 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}

Explicación:

# 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/⎕]