Vince il codice più corto per superare tutte le possibilità

Sono stati creati molti giochi basati sulla griglia che iniziano con una griglia di luci accese. Premendo una qualsiasi delle luci si attiva e disattiva quella luce e le quattro luci adiacenti ad essa. Quando una luce viene attivata, viene spenta o accesa, a seconda che sia stata accesa o spenta inizialmente. L'obiettivo è quello di colpire le luci in una sequenza che provoca lo spegnimento di tutte le luci alla fine.

"X" rappresenta le luci che sono accese. "O" rappresenta le luci che sono spente. "P" rappresenta quel quadrato che viene premuto.

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

L'input può essere preso direttamente da un file passato come argomento o come input standard. La prima riga di input conterrà x (1 <= x <= 20), la dimensione della griglia di luci, che significa x per x . La seconda riga conterrà y (0 <= y <= ( x * 3) ² ), il numero di luci inizialmente accese. Le righe y successive contengono le coordinate delle luci accese sulla griglia, nel formato di "colonna riga". Le luci che sono già accese (sono state precedentemente attivate) dovrebbero essere nuovamente disattivate. La riga successiva conterrà z , il numero di luci premuto. La z finale le linee contengono le coordinate delle luci premute, nell'ordine in cui sono state premute, nel formato di "colonna riga".

Nessun input sarà errato. Tutti i numeri saranno entro i limiti indicati della griglia.

L'output sarà la griglia finale dopo che tutte le luci sono state attivate. Dovrebbe essere una griglia n per n . Per ogni area che ha una luce accesa, dovrebbe essere usato il carattere maiuscolo "X". Per ogni area che ha una luce spenta, dovrebbe essere usato il carattere maiuscolo "O".

Le luci interessate dalla griglia devono essere ignorate. Attivare una luce sul bordo di una griglia dovrebbe influire solo sulle luci che si trovano sulla griglia stessa.

Casi test

Ingresso

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

Produzione

OXOO
XOXO
XOXO
OXOO

Ingresso

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

Produzione

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

Probabilmente si può giocare a golf molto più lontano.

• Solo console, stdin-> stdout. Testato su j602 su Linux.
• Supera entrambi i test forniti.
• Presuppone il limite superiore sano su X (nessuna precisione estesa)

Versione originale non modificata:

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 caratteri

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)

Lo stato delle luci è conservato in un unico (grande) variabile intera s. Gli XOR con maschere di bit vengono utilizzati per attivare / disattivare le luci. Tengo un pezzetto in più per riga per evitare avvolgenti.

Ruby 1.9, 167 caratteri

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

modifiche:

• (198 -> 191) Rimosse alcune cose non necessarie
• (191 -> 180) Semplificato il modo in cui viene analizzato l'input
• (180 -> 172) Le parentesi rimosse, utilizzare z[u]*=-1invece di z[u]=-z[u], rimuovere la variabile non utilizzata
• (172 -> 169) Alcune semplificazioni
• (169 -> 167) Semplificato un condizionale

Perl, 139 caratteri

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

Spiegazione:

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