Otrzymujesz pozycję na planszy do gry Go i ruch do gry. Musisz podać, czy ruch jest legalny, czy nie, oraz nową pozycję na tablicy, jeśli jest legalna.

Krótkie wyjaśnienie ruchów Go: gra polega na naprzemiennym umieszczaniu czarno-białych elementów („kamieni”) w pustych miejscach na kwadratowej planszy. Zestawy elementów tego samego koloru, które są ze sobą połączone (4-kierunkowe) są nazywane grupami. Puste miejsca na planszy, które sąsiadują z grupą (także czterokierunkowe) są uważane za „wolności” tej grupy. Grupa z 0 swobodami zostaje schwytana (usunięta z planszy). Ruch, który spowodowałby schwytanie własnej grupy („samobójstwo”) jest nielegalny, chyba że chwyta jedną lub więcej grup przeciwnika (zyskuje w ten sposób swobody, więc nie jest faktycznie schwytany).

Dla zainteresowanych nie musisz zajmować się ko (i superko), tzn. Możesz założyć, że łapanie ko jest legalne. Jeśli nie wiesz, co to znaczy, po prostu postępuj zgodnie z powyższymi zasadami, a wszystko będzie dobrze.

Wprowadzanie: liczba n między 2 a 19 (włącznie) reprezentująca rozmiar planszy, następnie n wierszy n liczb od 0 do 2 (włącznie) reprezentujących pozycję planszy, a następnie 3 liczby oddzielone spacją, reprezentujące ruch do wykonania. W pozycji na planszy 0 oznacza puste miejsce, 1 oznacza czarny kamień, a 2 oznacza biały kamień. Ruch daje kolumnę, rząd i kolor (1 lub 2) kamienia do umieszczenia. Kolumna i wiersz są oparte na 0, od 0 do n-1 (włącznie) i są liczone w tej samej kolejności, co wejście na płytce.

Możesz założyć, że dana pozycja zarządu jest legalna (wszystkie grupy mają co najmniej jedną swobodę).

Dane wyjściowe: wiersz zawierający 1 lub 0 (lub prawda / fałsz, jeśli wolisz), jeśli ruch jest legalny, czy nie, po którym następuje (tylko w przypadku legalnego ruchu) nowa pozycja tablicy w tym samym formacie co dane wejściowe.

Wynik: liczba bajtów pełnego kodu źródłowego, im mniejsza, tym lepiej. 20% dodatkowej kary za użycie znaków innych niż ascii i 20% dodatkowej kary, jeśli twój kod nie może być przetestowany w Linuksie przy użyciu swobodnie dostępnego oprogramowania.

Reguły: Brak połączeń sieciowych i bibliotek zewnętrznych. Twój program powinien używać standardowych strumieni wejściowych i wyjściowych lub standardowego odpowiednika dla Twojego języka programowania.

Przykłady:

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

Wykorzystuje 3 pola bitowe do przedstawienia planszy - po jednym dla czarnych, białych i pustych miejsc. Sprawia, że ​​znajdowanie sąsiadów Ni hoperacje łańcuchowe są bardzo zwięzłe.

Wersja bez golfa z dużą ilością komentarzy: 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()

Przejdź: przeanalizuj dane wejściowe, sprawdź, czy ruch jest w pustym miejscu, wykonaj ruch, zainicjuj siatkę „grupową”, uprość / zminimalizuj siatkę grupową, sprawdzając kolor sąsiednich kamieni (s = 0) i powtarzaj aż do pełnego zminimalizowania , sprawdź dla swobód grupowych (s = 1), usuń kamienie przeciwnika dla grup bez swobód (s = 2), powtórz s = 0 i s = 1, sprawdź, czy wszystkie grupy graczy mają wolności, zwróć wynik.

Można to prawdopodobnie znacznie skrócić ...

Przykład interaktywny działa:

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