Le code le plus court pour passer toutes les possibilités gagne

De nombreux jeux basés sur la grille ont été créés et commencent par une grille de lumières allumées. Appuyer sur l'une des lumières fait basculer cette lumière et les quatre lumières adjacentes. Lorsqu'une lumière est basculée, elle est éteinte ou allumée, selon qu'elle a été allumée ou éteinte initialement. Le but est de frapper les lumières dans une séquence qui aboutit à ce que toutes les lumières soient éteintes à la fin.

"X" représente les lumières allumées. "O" représente les lumières éteintes. "P" représente ce carré qui est pressé.

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'entrée peut être prise directement à partir d'un fichier passé en argument ou en entrée standard. La première ligne d'entrée contiendra x (1 <= x <= 20), la taille de la grille de lumières, signifiant x par x . La deuxième ligne contiendra y (0 <= y <= ( x * 3) ² ), le nombre de lumières initialement allumées. Les lignes y suivantes contiennent les coordonnées des lumières allumées sur la grille, au format de "colonne de ligne". Les lumières qui sont déjà allumées (ont été basculées précédemment) doivent être à nouveau désactivées. La ligne suivante contiendra z , le nombre de lumières appuyées. Le z final les lignes contiennent les coordonnées des lumières pressées, dans l'ordre où elles ont été pressées, au format de "colonne de ligne".

Aucune entrée ne sera incorrecte. Tous les nombres seront dans les limites données de la grille.

La sortie sera la grille finale après que toutes les lumières ont été basculées. Ce devrait être une grille n par n . Pour chaque zone dont la lumière est allumée, le caractère majuscule "X" doit être utilisé. Pour chaque zone dont la lumière est éteinte, le caractère majuscule "O" doit être utilisé.

Les lumières affectées qui sont hors du réseau doivent être ignorées. Le basculement d'une lumière sur le bord d'une grille ne devrait affecter que les lumières qui sont sur la grille elle-même.

Cas de test

Contribution

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

Production

OXOO
XOXO
XOXO
OXOO

Contribution

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

Production

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

Peut probablement être joué beaucoup plus loin.

• Console uniquement, stdin-> stdout. Testé sur j602 sous Linux.
• Réussit les deux tests donnés.
• Suppose une limite supérieure saine sur X (pas de précision étendue)

Version originale non golfée:

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 caractères

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)

L'état de la lumière est maintenue dans une seule (grande) variable entière, s. Les XOR avec bitmasks sont utilisés pour basculer les lumières. Je garde un bit supplémentaire par ligne pour éviter le bouclage.

Ruby 1.9, 167 caractères

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

Modifications:

• (198 -> 191) Suppression de certaines choses inutiles
• (191 -> 180) Simplification de la façon dont l'entrée est analysée
• (180 -> 172) Parenthèses supprimées, utilisez à la z[u]*=-1place de z[u]=-z[u], supprimez la variable inutilisée
• (172 -> 169) Quelques simplifications
• (169 -> 167) Simplifié un conditionnel

Perl, 139 caractères

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

Explication:

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