Der kürzeste Code, der alle Möglichkeiten erfüllt, gewinnt

Es wurden viele gitterbasierte Spiele entwickelt, die mit einem eingeschalteten Lichtgitter beginnen. Wenn Sie auf eine der Anzeigen drücken, werden diese Anzeige und die vier daneben liegenden Anzeigen umgeschaltet. Wenn ein Licht umgeschaltet wird, wird es ausgeschaltet oder eingeschaltet, je nachdem, ob es ursprünglich ein- oder ausgeschaltet war. Das Ziel ist es, die Lichter in einer Reihenfolge zu treffen, bei der alle Lichter am Ende ausgeschaltet werden.

"X" steht für eingeschaltete Lichter. "O" steht für Lichter, die ausgeschaltet sind. "P" steht für das Quadrat, das gedrückt wird.

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

Die Eingabe kann direkt aus einer als Argument übergebenen Datei oder als Standardeingabe erfolgen. Die erste Eingabezeile enthält x (1 <= x <= 20), die Größe des Lichtgitters, dh x mal x . Die zweite Zeile enthält y (0 <= y <= ( x * 3) ² ), die Anzahl der anfänglich leuchtenden Lichter. Die nächsten y- Zeilen enthalten die Koordinaten der leuchtenden Lichter im Raster im Format "Zeilenspalte". Bereits eingeschaltete (zuvor umgeschaltete) Lichter sollten wieder ausgeschaltet werden. Die nächste Zeile enthält z , die Anzahl der gedrückten Lichter. Das endgültige z Linien enthalten Koordinaten der gedrückten Lichter in der Reihenfolge, in der sie gedrückt wurden, im Format "Zeilenspalte".

Keine Eingabe wird falsch sein. Alle Zahlen liegen innerhalb der angegebenen Grenzen des Rasters.

Die Ausgabe ist das endgültige Raster, nachdem alle Lichter umgeschaltet wurden. Es sollte eine sein , n durch n Gitter. Für jeden Bereich, in dem ein Licht leuchtet, sollte das Großbuchstaben "X" verwendet werden. Für jeden Bereich, in dem das Licht ausgeschaltet ist, sollte das Großbuchstaben "O" verwendet werden.

Betroffene Lichter, die nicht am Netz sind, sollten ignoriert werden. Das Umschalten eines Lichts am Rand eines Gitters sollte nur die Lichter betreffen, die sich auf dem Gitter selbst befinden.

Testfälle

Eingang

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

Ausgabe

OXOO
XOXO
XOXO
OXOO

Eingang

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

Ausgabe

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

Vermutlich kann man noch viel weiter golfen.

• Nur Konsole, stdin-> stdout. Getestet auf j602 unter Linux.
• Besteht beide angegebenen Tests.
• Nimmt eine vernünftige Obergrenze für X an (keine erweiterte Genauigkeit)

Original ungolfed version:

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 Zeichen

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)

Der Status der Lichter wird in einer einzelnen (großen) Ganzzahlvariablen gespeichert s. XORs mit Bitmasken werden zum Umschalten der Lichter verwendet. Ich behalte ein zusätzliches Bit pro Zeile, um einen Umlauf zu verhindern.

Ruby 1.9, 167 Zeichen

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

Bearbeitungen:

• (198 -> 191) Einige unnötige Dinge wurden entfernt
• (191 -> 180) Vereinfacht die Art und Weise, wie die Eingabe analysiert wird
• (180 -> 172) Entfernte Klammern, verwenden Sie z[u]*=-1anstelle von z[u]=-z[u], entfernen Sie nicht verwendete Variablen
• (172 -> 169) Einige Vereinfachungen
• (169 -> 167) Vereinfacht eine Bedingung

Perl, 139 Zeichen

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

Erläuterung:

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