Introducción

Morris de Nine Mens (también llamado Mills) es un juego de mesa para dos jugadores que se juega en el siguiente tablero (imagen tomada de la página vinculada de Wikipedia):

Cada jugador tiene 9 hombres, de color blanco y negro. Las reglas concretas no son importantes para este desafío, pero consulte la página de Wikipedia si está interesado.

El reto

Dada una cuadrícula como entrada, que representa un cierto estado del tablero, genera el recuento total de molinos mcon 0<=m<=8.
Tres hombres del mismo color forman un molino cuando están en una fila recta de puntos conectados. b2que f2no es un molino ya que los hombres son de diferente color. También d2a d5no formar un molino ya que los tres puntos se tienen que conectar.
El tablero en la imagen de arriba contiene dos molinos, por ejemplo. Uno de f2a f6y uno de e3a e5.

Entrada

El tablero se representa como una cuadrícula 2D con 24 puntos que están conectados como se muestra en la imagen de ejemplo anterior. El ejemplo utiliza letras de a-gpara las columnas y números de 1-7para las filas, pero puede elegir cualquier formato de entrada razonable siempre que asigne 24 coordenadas únicas a uno de los siguientes estados:

• Vacío
• Tomado por negro
• Tomado por blanco

La representación concreta depende de usted, no está restringido a "b" o "w" para los colores.

Además de esto, su entrada puede no contener ninguna información adicional.

Notas adicionales

• No tiene que asignar los puntos por ningún tipo de valores. Si desea tomar la entrada como una matriz 2D, también está bien. Pero tenga en cuenta que no se utilizan todos los puntos allí y que debe considerar las conexiones entre ellos.
• La entrada puede estar vacía, en cuyo caso debe generar cero (placa vacía -> sin fresas).
• Como cada jugador tiene 9 hombres, la entrada nunca contendrá más de 18 puntos tomados.
• Puede dejar de lado los puntos vacíos en la entrada y, por lo tanto, solo los puntos de entrada que se toman.
• La entrada se puede ordenar de cualquier manera. No puede confiar en un pedido específico.
• Puede suponer que la entrada siempre será válida. Esto significa que no habrá más de 9 hombres de cada color y que cada punto será único.

Reglas

• Deje claro qué formato de entrada usa en su solución. Proporcionar un ejemplo de ejecución de su programa es altamente recomendable.
• Función o programa completo permitido.
• Reglas predeterminadas para entrada / salida.
• Se aplican lagunas estándar .
• Este es el código de golf , por lo que gana el conteo de bytes más bajo. Tiebreaker es una presentación anterior.

Casos de prueba

El formato de entrada aquí es una lista de tuplas con las coordenadas como en el ejemplo anterior como primer elemento y el estado del segundo elemento puntual. Un punto tomado por blanco se marca como "w" y un punto tomado por negro como "b". Todos los demás puntos quedan fuera y están vacíos.

[("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 codificación!

APL (Dyalog Classic) , 26 25 bytes

-1 gracias a FrownyFrog

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

Pruébalo en línea!

El argumento es una matriz de 3x3x3 de 1(negro), ¯1(blanco) y 0(vacío). La primera dimensión es a lo largo de la profundidad de anidación de los cuadrados concéntricos. Las otras dos dimensiones están a lo largo del eje vertical y 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

Tenemos un molino cada vez que la suma a lo largo de cualquier eje produce a 3o ¯3, excepto que debemos descartar las cuatro esquinas al sumar a lo largo del primer eje.

{} es una función con argumento implícito ⍵

↓⍵está dividido : en nuestro caso convierte un cubo de 3x3x3 en una matriz de 3x3 de vectores de longitud-3 anidados

⍵⍪↓⍵ toma el cubo original y pega la matriz 3x3 de 3 vectores debajo de él, por lo que obtenemos una matriz mixta 4x3x3 de escalares y vectores

+/sumas a lo largo del último eje; esto tiene el efecto combinado de sumar el cubo original a lo largo del último eje ( +/⍵) y sumarlo a lo largo del eje medio debido a la división que hicimos ( +/↓⍵)

Ahora debemos ocuparnos del caso especial para el primer eje.

+⌿⍵ sumas a lo largo del primer eje, devolviendo una matriz 3x3

4 2⍴ pero no debemos contar las esquinas, por lo que lo reformamos a una matriz de 4x2 como esta:

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

ahora solo nos interesa la última columna ( BDFH), así que usamos el idioma⊢/

,se concatena BDFHcon la matriz que obtuvimos antes para el segundo y tercer eje ( BDFHy la matriz tiene una dimensión principal de 4)

∊ aplana todo lo que obtuvimos hasta ahora en un solo vector

| toma los valores absolutos

{ }∩≢ filtra solo los tres: la longitud (≢) de la entrada siempre es 3

≢ los cuenta

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

(lo anterior contiene algunos caracteres ascii no imprimibles que no aparecerán aquí, así que aquí hay una versión sin la btoaque se puede copiar y ejecutar)

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

Rompe una cadena de referencia en tripletes de letras que coinciden con las claves de grupo de molino. La entrada tiene la forma de un objeto, donde las teclas son las letras a-x, comenzando desde la parte inferior izquierda y terminando en la parte superior derecha, moviéndose de izquierda a derecha primero. Los valores son 1para blanco, -1para negro y 0para blanco.

Ejemplo

{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

Estos ejemplos están tomados de los ejemplos de OP, convertidos en la letra-clave y el objeto de valor numérico. El primero es de la imagen de ejemplo, mientras que los otros son del conjunto de ejemplos.

Mathematica, 217 131 Bytes

Si bien estoy seguro de que esto no es particularmente competitivo, aquí hay una entrada para usted.

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

Ejemplo 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 nombres de coordenadas de un solo carácter trivialmente de 51 caracteres, lo que lo convierte en una solución de 166 bytes. Nombrando a los jugadores 1 y 2 en lugar de "w" y "b" golfs de 17 personajes más.

Entonces obtenemos

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

"La solución de los objetos"

Si bien es más largo (29 caracteres) que la solución de @ ngn , utiliza un enfoque completamente diferente: la entrada tiene la misma estructura general que esa solución, pero todas las ranuras se representan como objetos. Las ranuras vacías (incluida la columna central no existente) deben ser objetos vacíos. mientras que todos los hombres negros deben ser referencias al objeto "hombre negro", y todos los hombres blancos deben ser referencias al objeto "hombre blanco". Todos los objetos pueden tener opcionalmente agradable D isplay F ORM s para facilitar la lectura, y así la columna central puede estar opcionalmente hizo invisible.

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

Pruébalo en línea!

+/ la suma de

1=(... ) unos en

 ≢¨(... ) las cuentas de

  , el desaliñado (aplanado)

  ∪/ conjuntos únicos en

  , concatenado a

  ∪⌿⍤2 conjuntos únicos

 ,(... ) concatenado a

  ⊢/ la columna más a la derecha de

  4 2⍴ el, reformado en cuatro filas y dos columnas,

  ∪⌿ conjuntos columnares únicos

Un operador superior , como se suministra con AGL ( ä), reduciría la longitud a 27 caracteres .