Introdução

O Nine Mens's Morris (também chamado Mills) é um jogo de tabuleiro para dois jogadores, que é jogado no seguinte tabuleiro (imagem retirada da página da Wikipedia vinculada):

Cada jogador tem 9 homens, coloridos em preto e branco. As regras concretas não são importantes para esse desafio, mas verifique a página da Wikipedia se você estiver interessado.

O desafio

Dada uma grade como entrada, o que representa um certo boardstate, a saída do moinho de contagem total mcom 0<=m<=8.
Três homens da mesma cor formam um moinho quando estão em uma linha reta de pontos conectados. b2a f2não é um moinho, uma vez que os homens são de cor diferente. Também d2para d5não formar um moinho desde os três pontos têm de ser ligados.
A placa na imagem acima contém dois moinhos, por exemplo. Um de f2para f6e um de e3para e5.

Entrada

A placa é representada como uma grade 2D com 24 pontos, que são conectados como mostrado na imagem de exemplo acima. O exemplo usa letras de a-gpara as colunas e números 1-7para as linhas, mas você pode escolher qualquer formato de entrada razoável, desde que mapeie 24 coordenadas exclusivas para um dos seguintes estados:

• Esvaziar
• Lomografo: black
• Tirada por branco

A representação do concreto depende de você; você não está restrito a "b" ou "w" para as cores.

Além disso, sua entrada pode não conter nenhuma informação adicional.

Notas Adicionais

• Você não precisa mapear os pontos por nenhum tipo de valor. Se você deseja pegar a entrada como uma matriz 2D, tudo bem também. Mas lembre-se de que nem todos os pontos são usados ​​e que você deve considerar as conexões entre eles.
• A entrada pode estar vazia; nesse caso, você deve gerar zero (placa vazia -> sem fresas).
• Como cada jogador tem 9 homens, a entrada nunca conterá mais de 18 pontos conquistados.
• Você pode omitir pontos vazios na entrada e, portanto, apenas os pontos de entrada que são capturados.
• A entrada pode ser solicitada de qualquer forma. Você não pode confiar em um pedido específico.
• Você pode assumir que a entrada sempre será válida. Isso significa que não haverá mais de 9 homens de cada cor e que cada ponto será único.

Regras

• Esclareça qual formato de entrada você usa em sua solução. É altamente recomendável fornecer um exemplo de execução do seu programa.
• Função ou programa completo permitido.
• Regras padrão para entrada / saída.
• Aplicam-se brechas padrão .
• Isso é código-golfe , portanto, a menor contagem de bytes vence. O desempatador é uma inscrição anterior.

Casos de teste

O formato de entrada aqui é uma lista de tuplas com as coordenadas, como no exemplo acima, como primeiro elemento e o estado do segundo elemento do ponto. Um ponto tomado por branco é marcado como "w" e um ponto tomado por preto como "b". Todos os outros pontos são deixados de fora e estão vazios.

[("a4", "w"), ("b2", "b"), ("b4", "b"), ("c4", "b"), ("d1", "w") , ("d2", "w"), ("e3", "w"), ("e4", "w"), ("e5", "w"), ("f2", "b") , ("f4", "b"), ("f6", "b"), ("g4", "w")] -> 2
[("a1", "b"), ("a4", "b"), ("a7", "b"), ("b4", "b"), ("c4", "b") , ("d3", "w"), ("d2", "w"), ("d1", "w")] -> 3
[] -> 0
[("b4", "b"), ("a4", b "), (" c4 ", w")] -> 0
[("b4", "b"), ("a4", b "), (" c4 ", b")] -> 1
[("a1", "b"), ("a4", "b"), ("a7", "b"), ("b2", "b"), ("b4", "b") , ("b6", "b"), ("c3", "b"), ("c4", "b"), ("c5", "b"), ("e3", "w") , ("e4", "w"), ("e5", "w"), ("f2", "w"), ("f4", "w"), ("f6", "w") , ("g1", "w"), ("g4", "w"), ("g7", "w")] -> 8

Feliz codificação!

APL (Dyalog Classic) , 26 25 bytes

-1 graças a FrownyFrog

≢{|∊(+/⍵⍪↓⍵),⊢/4 2⍴+⌿⍵}∩≢

Experimente online!

O argumento é uma matriz 3x3x3 de 1(preto), ¯1(branco) e 0(vazio). A primeira dimensão é ao longo da profundidade de aninhamento dos quadrados concêntricos. As outras duas dimensões estão no eixo vertical e horizontal.

000---------001---------002
 |           |           |
 |  100-----101-----102  |
 |   |       |       |   |
 |   |  200-201-202  |   |
 |   |   |       |   |   |
010-110-210     212-112-012
 |   |   |       |   |   |
 |   |  220-221-222  |   |
 |   |       |       |   |
 |  120-----121-----122  |
 |           |           |
020---------021---------022

Temos um moinho sempre que a soma ao longo de qualquer eixo produza a 3ou ¯3, exceto que devemos descartar os quatro cantos ao somar ao longo do primeiro eixo.

{} é uma função com argumento implícito ⍵

↓⍵é dividido - no nosso caso, transforma um cubo 3x3x3 em uma matriz 3x3 de vetores comprimento-3 aninhados

⍵⍪↓⍵ pega o cubo original e cola a matriz 3x3 de 3 vetores abaixo dele, para obter uma matriz mista 4x3x3 de escalares e vetores

+/somas ao longo do último eixo; isso tem o efeito combinado de somar o cubo original ao longo do último eixo ( +/⍵) e somar ao longo do eixo do meio devido à divisão que fizemos ( +/↓⍵)

Agora devemos cuidar do caso especial do primeiro eixo.

+⌿⍵ soma ao longo do primeiro eixo, retornando uma matriz 3x3

4 2⍴ mas não devemos contar os cantos, por isso a remodelamos para uma matriz 4x2 como esta:

ABC      AB
DEF  ->  CD
GHI      EF
         GH  ("I" disappears)

agora estamos interessados ​​apenas na última coluna ( BDFH), então usamos o idioma⊢/

,concatena BDFHcom a matriz que obtivemos anteriormente para o segundo e o terceiro eixos ( BDFHe a matriz possui uma dimensão principal de 4)

∊ nivela tudo o que obtivemos até agora em um único vetor

| pega os valores absolutos

{ }∩≢ filtra apenas três - o comprimento (≢) da entrada é sempre 3

≢ conta eles

JavaScript (ES6), 276 228 125 117 105 bytes

a=>btoa`i·yø!9%z)ª»-ºü1j;ÝÈ%¥·¡ªÜ"·ç¹Ê1`.replace(/.../g,b=>(a[b[0]]+a[b[1]]+a[b[2]])/3&1||'').length

(o acima contém alguns caracteres ASCII imprimíveis que não aparecerão aqui, então aqui está uma versão sem a btoaque pode ser copiada e executada)

a=>'abcdefghijklmnopqrstuvwxajvdksglpbehqtwimrfnucox'.replace(/.../g,b=>(a[b[0]]+a[b[1]]+a[b[2]])/3&1||'').length

Divide uma sequência de referência em trigêmeos de letras que correspondem às chaves do grupo de fresadoras. A entrada está na forma de um objeto, onde as teclas são as letras a-x, começando na parte inferior esquerda e terminando na parte superior direita, movendo-se da esquerda para a direita primeiro. Os valores são 1para branco, -1preto e 0branco.

Exemplo

{b:1,d:-1,e:1,f:-1,i:1,k:-1,l:-1,m:1,n:-1,r:1,u:-1} => 2
{j:1,d:-1,k:-1,l:-1,b:1,e:1,i:1,m:1,r:1,f:-1,n:-1,u:-1,o:1} => 2
{a:-1,j:-1,v:-1,k:-1,l:-1,h:1,e:1,b:1} => 3
{} => 0
{k:-1,j:-1,l:1} => 0
{k:-1,j:-1,l:1} => 1
{a:-1,j:-1,v:-1,d:-1,k:-1,s:-1,g:-1,l:-1,p:-1,i:1,m:1,r:1,f:1,n:1,u:1,c:1,o:1,x:1} => 8

Esses exemplos são extraídos dos exemplos do OP, convertidos no objeto de letra da letra e número-valor. O primeiro é da imagem de exemplo, enquanto os outros são do conjunto de exemplos.

Mathematica, 217 131 bytes

Embora eu tenha certeza de que isso não é particularmente competitivo, aqui está uma entrada para você.

Count[Total/@{{a1,d1,g1},{b2,d2,f2},{c3,d3,e3},{a4,b4,c4},{e4,f4,g4},{c5,d5,e5},{b6,d6,f6},{a7,d7,g7},{a1,a4,a7},{b2,b4,b6},{c3,c4,c5},{d1,d2,d3},{d5,d6,d7},{e3,e4,e5},{f2,f4,f6},{g1,g4,g7}}/.#/.{"w"->1,"b"->2},3|6]&

Exemplo de entrada:

{a4 -> "w", b2 -> "b", b4 -> "b", c4 -> "b", d1 -> "w", d2 -> "w", e3 -> "w", e4 -> "w", e5 -> "w", f2 -> "b", f4 -> "b", f6 -> "b", g4 -> "w"}

Permitir que os nomes de coordenadas de um caractere reduzam trivialmente 51 caracteres, tornando-o uma solução de 166 bytes. Nomear os jogadores 1 e 2 em vez de "w" e "b" joga com mais 17 personagens.

Então nós temos

Count[Total/@{a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,a,j,v,d,k,s,g,l,p,b,e,h,q,t,w,r,i,m,f,u,n,c,o,x}~Partition~3,3|6]/.#&

APL (Dyalog Unicode) , 50 bytes

"A solução dos objetos"

Embora seja mais longa (29 caracteres) do que a solução da @ ngn , ela usa uma abordagem totalmente diferente: A entrada tem a mesma estrutura geral que a solução, mas todos os slots são representados como objetos. Os slots vazios (incluindo a coluna central não existente) devem ser objetos vazios. enquanto todos os homens negros devem ser referências ao objeto "homem negro", e todos os homens brancos devem ser referências ao objeto "homem branco". Todos os objectos podem, opcionalmente, ter bom D isplay F orm s para facilitar a leitura, e assim a coluna central pode, opcionalmente, ser tornada invisível.

+/1=(≢¨(,∪/,∪⌿⍤2),(⊢/4 2⍴∪⌿))

Experimente online!

+/ a soma de

1=(... ) aqueles em

 ≢¨(… Os ) tallys de

  , o enredado (achatado)

  ∪/ conjuntos únicos em

  , concatenado para

  ∪⌿⍤2 conjuntos únicos

 ,(...)  concatenado para

  ⊢/ a coluna mais à direita da

  4 2⍴ remodelado em quatro linhas e duas colunas,

  ∪⌿ conjuntos colunares exclusivos

Um operador no topo , como fornecido com AGL ( ä), reduziria o comprimento para 27 caracteres .