Wygrywa najkrótszy kod, który przejdzie wszystkie możliwości

Powstało wiele gier opartych na siatce, które zaczynają się od włączonej siatki świateł. Naciśnięcie któregokolwiek ze świateł powoduje przełączenie tego światła i czterech sąsiadujących z nim świateł. Kiedy światło jest przełączane, jest ono wyłączane lub włączane, w zależności od tego, czy zostało celowo włączone, czy wyłączone. Celem jest uderzenie w światła w sekwencji, w wyniku której wszystkie światła zostaną wyłączone na końcu.

„X” oznacza włączone światła. „O” oznacza wyłączone światła. „P” oznacza naciskany kwadrat.

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

Dane wejściowe można pobierać bezpośrednio z pliku przekazanego jako argument lub jako dane standardowe. Pierwszy wiersz danych wejściowych będzie zawierał x (1 <= x <= 20), wielkość siatki świateł, oznaczającą x na x . Drugi wiersz będzie zawierał y (0 <= y <= ( x * 3) ² ), liczba początkowo zapalonych świateł. Następne y wierszy zawierają współrzędne zapalonych świateł na siatce, w formacie „kolumny wiersza”. Światła, które są już włączone (wcześniej były wyłączone), należy ponownie wyłączyć. Następny wiersz będzie zawierał z , liczbę wciśniętych świateł. Ostateczne z linie zawierają współrzędne wciśniętych świateł w kolejności, w jakiej zostały wciśnięte, w formacie „kolumny wiersza”.

Żadne dane wejściowe nie będą niepoprawne. Wszystkie liczby mieszczą się w podanych granicach siatki.

Wyjście będzie ostatnią siatką po przełączeniu wszystkich świateł. Powinno to być n na n siatka . Dla każdego obszaru, który ma włączone światło, należy użyć wielkiej litery „X”. Dla każdego obszaru z wyłączonym światłem należy użyć wielkiej litery „O”.

Światła, których to dotyczy, są wyłączone z siatki, należy je zignorować. Przełączanie światła na krawędzi siatki powinno wpływać tylko na światła znajdujące się na samej siatce.

Przypadki testowe

Wejście

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

Wynik

OXOO
XOXO
XOXO
OXOO

Wejście

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

Wynik

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

Prawdopodobnie można grać w golfa znacznie dalej.

• Tylko konsola, stdin-> stdout. Testowany na j602 w systemie Linux.
• Przechodzi oba podane testy.
• Zakłada rozsądny górny limit na X (bez rozszerzonej precyzji)

Oryginalna wersja bez golfa:

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

Python, 209 203 199 znaków

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)

Stan lampek są przechowywane w jednym (big) zmiennej Integer s. XOR z maskami bitowymi służą do przełączania świateł. Trzymam dodatkowy bit na wiersz, aby zapobiec zawijaniu.

Ruby 1.9, 167 znaków

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

Edycje:

• (198 -> 191) Usunięto niepotrzebne rzeczy
• (191 -> 180) Uproszczono sposób analizowania danych wejściowych
• (180 -> 172) Usunięto nawiasy, użyj z[u]*=-1zamiast z[u]=-z[u], usuń nieużywaną zmienną
• (172 -> 169) Niektóre uproszczenia
• (169 -> 167) Uproszczono warunek

Perl, 139 znaków

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

Wyjaśnienie:

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