Reinas que se atacan mutuamente

26

Deje que un tablero de ajedrez de 8x8 esté representado por dos valores distintos, uno de los cuales es un cuadrado vacío y el otro una reina. En los siguientes ejemplos, uso 0s como cuadrados vacíos y 1s como reinas. Por ejemplo:

Reinas en un tablero de ajedrez

es dado por

1 0 1 1 1 0 0 0
1 0 1 0 1 0 1 1
1 0 1 0 1 1 0 1
0 1 0 1 0 1 0 0
0 1 1 0 0 1 0 1
1 0 0 0 1 0 0 0
0 1 0 0 0 1 1 1
0 1 1 1 0 1 0 1

Considere el número de pares de reinas que están atacando a cada uno que están al menos a un cuadrado de distancia (como recordatorio, las reinas atacan ortogonal y diagonalmente). En el ejemplo anterior, el siguiente diagrama feo increíble muestra todos estos pares como flechas.

Atacar reinas

Hay 43 pares encontrados arriba que dan el siguiente caso de prueba:

Input:
1 0 1 1 1 0 0 0
1 0 1 0 1 0 1 1
1 0 1 0 1 1 0 1
0 1 0 1 0 1 0 0
0 1 1 0 0 1 0 1
1 0 0 0 1 0 0 0
0 1 0 0 0 1 1 1
0 1 1 1 0 1 0 1
Output: 43

Reto

Escriba un programa que, dado un estado de tablero representado por dos valores distintos, genere el número de pares de reinas que se atacan entre sí con al menos un cuadrado entre ellas.

  • Puede ingresar en el formato que sea más conveniente que use dos valores para representar los cuadrados vacíos y las reinas, por ejemplo, una cadena de 64 "." S para cuadrados vacíos y "Q" s para reinas por filas de abajo hacia arriba, un 8x8 matriz de booleanos, una lista de la lista de enteros 0 y 1, etc., siempre que se explique en su solución
  • La salida es un entero
  • Se aplican métodos de E / S estándar y se prohíben las lagunas estándar
  • Este es el código de golf, por lo que la respuesta más corta en bytes gana

Casos de prueba:

Usando el formato 0 y 1, con 0 siendo cuadrados vacíos y 1 siendo reinas:

Input:
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
Output: 0

Input:
1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1
Output: 0

Input:
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 1 0 0 0 0 1 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
Output: 1

Input:
0 0 0 0 0 0 0 0
0 0 0 1 0 0 0 0
0 0 0 0 1 0 0 0
0 1 0 0 0 0 1 0
0 0 0 0 1 0 1 0
0 0 0 0 0 0 0 0
0 0 0 1 0 0 1 0
0 0 0 0 0 0 0 0
Output: 10

Input:
1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1
1 1 1 1 0 1 1 1
1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1
Output: 4

Input:
1 1 0 1 1 1 1 1
1 1 1 1 1 1 1 1
1 1 1 1 0 1 1 1
1 1 1 1 0 1 1 1
1 1 1 1 0 1 1 1
1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1
Output: 11
code-golf chess binary-matrix JMigst
fuente
Debería haber preguntado antes de publicar mi segunda versión: ¿son 254 para una reina y 0 para un cuadrado vacío con valores de entrada aceptables?
Arnauld
@Arnauld Puede ingresar en el formato más conveniente que use dos valores para representar los cuadrados vacíos y las reinas. Así que eso está bien seguro
JMigst
Gracias. Pregunté porque creo que esta regla podría ser demasiado permisiva si se toma literalmente. Podría pedirle que pase una cadena que contenga la mayor parte del código JS para las reinas y simplemente evaluar eso en el programa. (Pero puede ser impedido por una escapatoria predeterminada. No estoy seguro.)
Arnauld

Respuestas:

14

Python 2 , 105 bytes

lambda b:sum(b[i+d::d][:(8,7-i%8,i%8)[d%8%5]].find('1')*int(c)>0for i,c in enumerate(b)for d in[1,7,8,9])

Pruébalo en línea!

Explicación

Tomamos la entrada como una cadena de 64 caracteres '0'o '1'. Usando cortes escalonados, lanzamos cuatro "líneas de visión" de cada reina que encontramos. Por ejemplo, cuando i = 10 y d = 7 , marcando la reina como ♥ y los azulejos seleccionados por b[i+d::d]como █:

1 0 1 1 1 0 0 0
1 0 ♥ 0 1 0 1 1
1 █ 1 0 1 1 0 1
█ 1 0 1 0 1 0 █
0 1 1 0 0 1 █ 1
1 0 0 0 1 █ 0 0
0 1 0 0 █ 1 1 1
0 1 1 █ 0 1 0 1

Claramente, en realidad no queremos que la visión se ajuste al tablero de esta manera. Así que calculamos qué tan lejos está el borde del tablero en cada dirección, y vemos los mosaicos en b[i+d::d][:…].

Para cada par de dirección de mosaico contamos:

ray.find('1')*int(c)>0

Esto fallará siempre

  • cno es una reina; o
  • la reina que ve este rayo está demasiado cerca ( finddevuelve 0); o
  • este rayo no ve reina ( finddevuelve -1).

Cada par de reinas solo se verifica una vez, ya que los rayos siempre se proyectan hacia adelante con el fin de leer, de una reina "anterior" a uno "más adelante".

Lynn
fuente
10

JavaScript (ES7), 86 bytes

Toma datos como una matriz de 64 enteros con 254 para una reina y 0 para un cuadrado vacío.

a=>[s=0,6,7,8].map(d=>a.map(g=(n,p)=>(p%8-(p+=~d)%8)**2<n%4?a[p]?s+=n&1:g(n/2,p):0))|s

Pruébalo en línea!

Esta versión abusa del flujo inferior aritmético para obtener una condición de detención en la parte recursiva.

JavaScript (ES7), 89 bytes

Toma entrada como una matriz de 64 bits.

a=>[s=0,6,7,8].map(d=>a.map(g=(n,p,x)=>(p%8-(p+=~d)%8)**2>1|p<0?0:a[p]?s+=!x&n:g(n,p)))|s

Pruébalo en línea!

¿Cómo?

Llamamos recursivamente a una función de devolución de llamada con nombre de map()caminar por los cuadrados en una dirección determinada. Aunque realmente no necesitamos el contenido del tercer parámetro de la devolución de llamada ( map()se solicitó la matriz ), indirectamente lo usamos para saber si es la primera iteración o no.

arr.map (devolución de llamada de función (currentValue [, index [, array]])

Esta es la variable x en el código.

a =>                        // given the input array a[]
  [ s = 0,                  // initialize the sum s to 0
    6, 7, 8 ].map(d =>      // for each direction d in [0, 6, 7, 8]:
    a.map(g = (n, p, x) =>  //   for each square n at position p in a[]:
      (                     //     we are out of the board if:
        p % 8 -             //       - abs(p % 8 - p' % 8) is greater than 1
        (p += ~d) % 8       //         where p' = p - (d + 1)
      ) ** 2 > 1 |          //         (squaring is shorter than using Math.abs)
      p < 0 ?               //       - or p' is less than 0
        0                   //       if so, stop recursion
      :                     //     else:
        a[p] ?              //       if there's a queen on the target square:
          s +=              //         increment s if:
            !x &            //           x is undefined (this is not the 1st iteration)
            n               //           and n = 1 (there's a queen on the source square)
        :                   //       else:
          g(n, p)           //         do a recursive call to g(), with x undefined
    )                       //   end of inner map()
  ) | s                     // end of outer map(); return s
Arnauld
fuente
8

Caracoles , 14 bytes

A
rdaa7\1\0+\1

Pruébalo en línea!

La entrada es el formato 0/1, sin espacios dentro de las líneas.

Snails fue creado para un desafío de PPCG de diseño de lenguaje de coincidencia de patrones 2D . Lo más importante es que, por defecto, genera el número de coincidencias encontradas, lo cual es perfecto para este desafío.

A establece la opción "todos los caminos", de modo que si una reina está en varios pares, cada uno de esos pares generaría una coincidencia.

rdaa7establece la dirección del partido en S, SE, E y NE. Establecer en todas las direcciones ( z) causaría un doble recuento.

\1\0+\1coincide con a 1, luego uno o más 0s, luego otro 1.

TwiNight
fuente
6

APL (Dyalog Classic) , 41 39 32 bytes

(+/+⌿-⌈⌿)2<⌿0⍪⊢,⍉,8 31⍴⊢,≠⍨,⌽,≠⍨

Pruébalo en línea!

≠⍨ es "no igual a sí mismo" - una matriz de 8x8 todo cero

⊢,≠⍨,⌽,≠⍨- si la matriz original es ABC..., esta expresión devuelve:

A B C D E F G H 0 0 0 0 0 0 0 0 H G F E D C B A 0 0 0 0 0 0 0 0
I J K L M N O P 0 0 0 0 0 0 0 0 P O N M L K J I 0 0 0 0 0 0 0 0
Q R S T U V W X 0 0 0 0 0 0 0 0 X W V U T S R Q 0 0 0 0 0 0 0 0
Y Z A B C D E F 0 0 0 0 0 0 0 0 F E D C B A Z Y 0 0 0 0 0 0 0 0
G H I J K L M N 0 0 0 0 0 0 0 0 N M L K J I H G 0 0 0 0 0 0 0 0
O P Q R S T U V 0 0 0 0 0 0 0 0 V U T S R Q P O 0 0 0 0 0 0 0 0
W X Y Z A B C D 0 0 0 0 0 0 0 0 D C B A Z Y X W 0 0 0 0 0 0 0 0
E F G H I J K L 0 0 0 0 0 0 0 0 L K J I H G F E 0 0 0 0 0 0 0 0

8 31⍴ le da nueva forma de 8x32 a 8x31, reutilizando los elementos en orden de fila mayor:

A B C D E F G H 0 0 0 0 0 0 0 0 H G F E D C B A 0 0 0 0 0 0 0
0 I J K L M N O P 0 0 0 0 0 0 0 0 P O N M L K J I 0 0 0 0 0 0
0 0 Q R S T U V W X 0 0 0 0 0 0 0 0 X W V U T S R Q 0 0 0 0 0
0 0 0 Y Z A B C D E F 0 0 0 0 0 0 0 0 F E D C B A Z Y 0 0 0 0
0 0 0 0 G H I J K L M N 0 0 0 0 0 0 0 0 N M L K J I H G 0 0 0
0 0 0 0 0 O P Q R S T U V 0 0 0 0 0 0 0 0 V U T S R Q P O 0 0
0 0 0 0 0 0 W X Y Z A B C D 0 0 0 0 0 0 0 0 D C B A Z Y X W 0
0 0 0 0 0 0 0 E F G H I J K L 0 0 0 0 0 0 0 0 L K J I H G F E

⊢,⍉, antepone la matriz original y su transposición (espacios adicionales para mayor claridad):

A B C D E F G H  A I Q Y G O W E  A B C D E F G H 0 0 0 0 0 0 0 0 H G F E D C B A 0 0 0 0 0 0 0
I J K L M N O P  B J R Z H P X F  0 I J K L M N O P 0 0 0 0 0 0 0 0 P O N M L K J I 0 0 0 0 0 0
Q R S T U V W X  C K S A I Q Y G  0 0 Q R S T U V W X 0 0 0 0 0 0 0 0 X W V U T S R Q 0 0 0 0 0
Y Z A B C D E F  D L T B J R Z H  0 0 0 Y Z A B C D E F 0 0 0 0 0 0 0 0 F E D C B A Z Y 0 0 0 0
G H I J K L M N  E M U C K S A I  0 0 0 0 G H I J K L M N 0 0 0 0 0 0 0 0 N M L K J I H G 0 0 0
O P Q R S T U V  F N V D L T B J  0 0 0 0 0 O P Q R S T U V 0 0 0 0 0 0 0 0 V U T S R Q P O 0 0
W X Y Z A B C D  G O W E M U C K  0 0 0 0 0 0 W X Y Z A B C D 0 0 0 0 0 0 0 0 D C B A Z Y X W 0
E F G H I J K L  H P X F N V D L  0 0 0 0 0 0 0 E F G H I J K L 0 0 0 0 0 0 0 0 L K J I H G F E

2<⌿0⍪agrega 0s en la parte superior y compara usando <cada elemento contra el elemento debajo de él, por lo que obtenemos un 1 para el 1 inicial en cada grupo vertical de 1s, y obtenemos 0s en cualquier otro lugar

+⌿-⌈⌿ las sumas por columna menos los máximos por columna: calculamos el número de espacios entre los grupos 1 en cada columna, 0 si no hay ninguno

+/ suma

ngn
fuente
5

Jalea , 22 20 bytes

t0ŒgL:2
Z,U;ŒD$€ẎÇ€S

Pruébalo en línea!

usuario202729
fuente
¿Como funciona esto?
lirtosiast el
@lirtosiast no recuerdo ...
user202729
@lirtosiast El primer enlace cuenta el número de pares en 1D, el segundo enlace toma la suma del primer enlace sobre todas las líneas de la tabla.
usuario202729
3

Retina 0.8.2 , 60 58 bytes

1
¶1$';___¶
_
$n$%`7$*_
(.)(?=.*;(_)*)(?<-2>.)*
$1
m`^10+1

Pruébalo en línea! Toma la entrada como 8 cadenas binarias de 8 caracteres separadas por comas, pero el encabezado convierte el formato proporcionado por usted. Explicación:

1
¶1$';___¶

Crea todas las subcadenas del tablero comenzando en una reina. Sufije un valor de marcador a cada subcadena. Editar: guardado 2 bytes dejando algunas cadenas de basura detrás; estos son efectivamente ignorados.

_
$n$%`7$*_

Divida cada marcador en un rango inclusivo y agregue 7 a los elementos distintos de cero.

(.)(?=.*;(_)*)(?<-2>.)*
$1

Elimine cada serie de caracteres que sea igual a la longitud del marcador. Esto es equivalente a encontrar cada rayo este, suroeste, sur o sureste de cada reina.

m`^10+1

Cuenta todos los rayos que pasan por al menos un cuadrado vacío antes de conocer a otra reina.

Neil
fuente
3

JavaScript (ES6) + SnakeEx , 38 bytes

s=>snakeEx.run('m:<*>10+1',s).length/2

Toma entrada en el formulario '10111000\n10101011\n10101101\n01010100\n01100101\n10001000\n01000111\n01110101'. Resulta que SnakeEx todavía se puede usar fuera de su desafío original.

LegionMammal978
fuente