Te dan una posición en el tablero para un juego de Go y un movimiento para jugar. Debe indicar si el movimiento es legal o no, y la nueva posición del tablero si es legal.

Una breve explicación de los movimientos de Go: el juego consiste en colocar alternativamente piezas en blanco y negro ("piedras") en lugares vacíos en un tablero cuadrado. Los conjuntos de piezas del mismo color que están conectados entre sí (4 vías) se denominan grupos. Los lugares vacíos en el tablero adyacentes a un grupo (también de 4 vías) se consideran las "libertades" de ese grupo. Se captura un grupo con 0 libertades (se elimina del tablero). Un movimiento que haría que su propio grupo fuera capturado ("suicidio") es ilegal, a menos que esté capturando a uno o más grupos del oponente (obteniendo libertades en el proceso para que no sea capturado).

Para los interesados, no es necesario tratar con ko (y superko), es decir, puede asumir que una captura de ko es legal. Si no sabe lo que eso significa, simplemente siga las reglas anteriores y estará bien.

Entrada: un número n entre 2 y 19 (inclusive) que representa el tamaño del tablero, seguido de n líneas de n números entre 0 y 2 (inclusive) que representan la posición del tablero, seguido de 3 números separados por espacio, que representan el movimiento a realizar. En la posición del tablero, 0 significa lugar vacío, 1 significa piedra negra y 2 significa piedra blanca. El movimiento le da a la columna, la fila y el color (1 o 2) de la piedra para colocar. La columna y la fila están basadas en 0, que van de 0 a n-1 (inclusive) y se cuentan en el mismo orden que la entrada de la placa.

Puede suponer que la posición de la junta dada es legal (todos los grupos tienen al menos una libertad).

Salida: una línea que contiene 1 o 0 (o verdadero / falso si lo prefiere) si el movimiento es legal o no, seguido (solo en caso de un movimiento legal) por la nueva posición del tablero en el mismo formato que la entrada.

Puntuación: Número de bytes del código fuente completo, más pequeño es mejor. 20% de penalización adicional por el uso de caracteres no ASCII, y 20% de penalización adicional si su código no puede ser probado en Linux utilizando software disponible gratuitamente.

Reglas: sin conexiones de red y sin bibliotecas de terceros. Su programa debe usar los flujos de entrada y salida estándar, o el equivalente estándar para su lenguaje de programación.

Ejemplos:

1) Input:

2
10
01
1 0 2

Output:

0

2) Input:

2
10
11
1 0 2

Output:

1
02
00

3) Input:

5
22122
22021
11211
02120
00120
2 1 1

Output:

1
00100
00101
11011
02120
00120

4) Input:

6
000000
011221
121121
122221
011110
000000
4 0 1

Output:

1
000010
011221
121121
122221
011110
000000

Python 3 (557 504 488)

import sys
s=sys.stdin
M=int(next(s))+1
j=Z=M*M-M
S=s.read(Z)
P=0
b=[0]*3
while j>0:j-=1+(j%M<1);b[int(S[j])]|=1<<j;P|=1<<j
N=lambda x:(x<<1|x>>1|x<<M|x>>M)&P&~x
def h(a,b):t=a|N(a)&b;return h(t,b)if t!=a else a
c,r,m=map(int,next(s).split())
o=m%2+1
p=1<<M*r+c
b[m]|=p
for n in(p<<1,p>>1,p<<M,p>>M):
 e=h(n&P,b[o])
 if~b[m]&N(e)<1<=n&b[o]:b[o]&=~e
_,B,W=b
g=~b[o]&N(h(p,b[m]))>=1>~_&p
print(+g)
q=''
while j<Z:
 r=1<<j
 if g*j%M>M-2:print(q);q=''
 else:q+='012E'[(r&B>0)+(r&W>0)*2]
 j+=1

Utiliza 3 campos de bits para representar el tablero, uno para espacios negros, blancos y vacíos. Hace que la búsqueda de vecinos Ny las hoperaciones de cadena sean muy concisas.

Una versión sin golf con muchos comentarios: https://gist.github.com/airfrog/8429006

Python ( 912 1004)

def o():
 n=int(raw_input(''))
 i=[raw_input('') for r in range(n+1)]
 b=[map(int,list(r)) for r in i[:n]]
 u,v,w=map(int,i[n].split(' '))
 if b[v][u]!=0:return 0
 b[v][u]=w
 if w==1:q=2
 elif w==2:q=1
 else:return 0
 f=[[],[],[]]
 h=[[],[],[]]
 g=[range(z*n,(z+1)*n) for z in range(n)]
 d=[(1,0),(-1,0),(0,1),(0,-1)]
 m=lambda z:max(0,min(n-1,z))
 t=[0,1,2,0,1]
 for j,s in enumerate(t):
  for r in range(n):
   for c in range(n):
    for y,x in map(lambda p:(m(r+p[0]),m(c+p[1])),d):
     if s==0:
      if b[y][x]==b[r][c]:
       if g[y][x]!=min(g[y][x],g[r][c]):
        t.insert(j+1,0)
       g[y][x]=g[r][c]=min(g[y][x],g[r][c])
     elif s==1:
      if g[r][c] not in h[b[r][c]]:
       h[b[r][c]].append(g[r][c])
      if b[y][x]==0 and g[r][c] not in f[b[r][c]]:
       f[b[r][c]].append(g[r][c])
    if s==2:
     if b[r][c]==q and g[r][c] not in f[b[r][c]]:
      b[r][c]=0
 h[w].sort()
 f[w].sort()
 if h[w]!=f[w]:return 0
 return "1\n"+'\n'.join([''.join(map(str,r)) for r in b])
print o()

Recorrido: analice la entrada, verifique si el movimiento está en un lugar vacío, haga el movimiento, inicie la cuadrícula de "grupo", simplifique / minimice la cuadrícula de grupo verificando el color de las piedras adyacentes (s = 0) y siga repitiendo hasta que esté completamente minimizado , verifique para las libertades grupales (s = 1), elimine las piedras del oponente para los grupos sin libertades (s = 2), repita s = 0 y s = 1, verifique que todos los grupos de jugadores tengan libertades, devuelva el resultado.

Esto probablemente se puede acortar significativamente ...

Ejemplo interactivo corre:

2
10
01
1 0 2
0

2
10
11
1 0 2
1
02
00

5
22122
22021
11211
02120
00120
2 1 1
1
00100
00101
11011
02120
00120

6
000000
011221
121121
122221
011110
000000
4 0 1
1
000010
011221
121121
122221
011110
000000