On vous donne une position de plateau pour une partie de Go et un coup pour jouer. Vous devez indiquer si le mouvement est légal ou non, et la nouvelle position du conseil d'administration si elle est légale.

Une brève explication des mouvements de Go: le jeu consiste à placer alternativement des pièces noires et blanches ("pierres") dans des endroits vides sur un plateau carré. Les ensembles de pièces de la même couleur qui sont connectés les uns aux autres (4 voies) sont appelés groupes. Les espaces vides sur le tableau qui sont adjacents à un groupe (également à 4 voies) sont considérés comme les "libertés" de ce groupe. Un groupe avec 0 libertés est capturé (retiré du tableau). Un mouvement qui entraînerait la capture de son propre groupe ("suicide") est illégal, à moins qu'il ne capture un ou plusieurs groupes adverses (gagnant ainsi des libertés afin qu'il ne soit pas réellement capturé).

Pour les personnes concernées, vous n'avez pas besoin de traiter avec ko (et superko), c'est-à-dire que vous pouvez supposer qu'une capture de ko est légale. Si vous ne savez pas ce que cela signifie, suivez simplement les règles ci-dessus et tout ira bien.

Entrée: un nombre n compris entre 2 et 19 (inclus) représentant la taille de la carte, suivi de n lignes de n nombres compris entre 0 et 2 (inclus) représentant la position de la carte, suivis de 3 chiffres séparés par un espace, représentant le mouvement à effectuer. En position de plateau, 0 signifie place vide, 1 signifie pierre noire et 2 signifie pierre blanche. Le mouvement donne la colonne, la ligne et la couleur (1 ou 2) de la pierre à placer. La colonne et la ligne sont basées sur 0, allant de 0 à n-1 (inclus) et comptées dans le même ordre que l'entrée de la carte.

Vous pouvez supposer que le poste donné au conseil d'administration est légal (tous les groupes ont au moins une liberté).

Sortie: une ligne contenant 1 ou 0 (ou vrai / faux si vous préférez) si le mouvement est légal ou non, suivi (uniquement en cas de mouvement légal) par la nouvelle position du tableau dans le même format que l'entrée.

Score: Nombre d'octets du code source complet, plus petit est meilleur. 20% de pénalité supplémentaire pour l'utilisation de caractères non-ascii et 20% de pénalité supplémentaire si votre code ne peut pas être testé sous Linux à l'aide d'un logiciel disponible gratuitement.

Règles: Aucune connexion réseau et aucune bibliothèque tierce. Votre programme doit utiliser les flux d'entrée et de sortie standard, ou l'équivalent standard pour votre langage de programmation.

Exemples:

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

Utilise 3 champs binaires pour représenter la carte - un pour les espaces noirs, blancs et vides. Rend les voisins proches Net les hopérations de chaîne très concis.

Une version non golfée avec beaucoup de commentaires: 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()

Parcourez: analysez l'entrée, vérifiez si le mouvement est sur un emplacement vide, effectuez le mouvement, initiez la grille de "groupe", simplifiez / minimisez la grille de groupe en vérifiant la couleur des pierres adjacentes (s = 0) et continuez à répéter jusqu'à ce qu'elle soit complètement minimisée , vérifiez pour les libertés de groupe (s = 1), retirez les pierres adverses pour les groupes sans liberté (s = 2), répétez s = 0 et s = 1, vérifiez que tous les groupes de joueurs ont des libertés, retournez le résultat.

Cela peut probablement être considérablement raccourci ...

L' exemple interactif s'exécute:

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