(inspirado por la respuesta de Helka a mi combinación aleatoria de etiquetas "ajedrez" y "Fibonacci" en el chat)

Fibonacci

Los números de Fibonacci son una de las secuencias más conocidas en matemáticas, donde cada número se compone sumando los dos números anteriores. A continuación se muestra una definición de la secuencia de índice cero:

f(0) = 0
f(1) = 1
f(n) = f(n-1) + f(n-2)

Esto da como resultado la secuencia 0, 1, 1, 2, 3, 5, 8, 13, 21, ...( enlace OEIS ). En este desafío, nos centraremos solo en los valores estrictamente positivos (así 1, 1, 2, 3, ...), y puede elegir indexación cero o indexación única, pero indique cuál en su envío.

Los números de Fibonacci se pueden usar para un mosaico del plano, mediante el uso de cuadrados f(n)de tamaño sucesivo y alineando sus bordes. El mosaico se realiza en sentido antihorario, colocando cuadrados en el patrón "derecha-arriba-izquierda-abajo" desde el cuadrado actual. Un ejemplo de este mosaico parcial para f(8)=21, con el cuadrado inicial resaltado en azul, es el siguiente:

Se puede ver el f(1)=1que la casilla de salida (resaltado en azul), el f(2)=1cuadrado situado a la derecha de la misma, el f(3)=2cuadrado colocado arriba a partir de ahí, el f(4)=3cuadrado colocado izquierda y así sucesivamente. El siguiente cuadrado sería f(9)=21+13=34y se colocaría en la parte inferior. Este es el método de mosaico parcial que usaremos en este desafío.

Las reinas

En el juego de ajedrez , la pieza más poderosa es la reina porque puede mover cualquier cantidad de espacios horizontal, vertical o diagonal. En el siguiente diagrama del tablero, los cuadrados con un círculo negro muestran dónde puede moverse la reina:

Definiremos el término cobertura como

El porcentaje de casillas a las que la reina puede moverse frente al número total de casillas, dada la posición particular de la reina en un tablero vacío, e incluyendo la posición inicial de la propia reina.

Para el ejemplo anterior, la cobertura de la reina es 28/64 = 43.75%. Si la reina estuviera en el h8cuadrado superior derecho , la cobertura sería 22/64 = 34.375%. Si la reina estuviera adentro e7, la cobertura sería 24/64 = 37.5%.

El reto

Vamos a utilizar el mosaico de Fibonacci demostrado anteriormente como nuestro tablero de ajedrez para este desafío. Se le darán dos enteros positivos como entrada ny x:

• El nrepresenta qué tan grande es el mosaico. El ejemplo de mosaico anterior, con el 21cuadrado a la izquierda, es un tablero de tamaño n = 8desde f(8) = 21(cuando está indexado a cero).
• El xrepresenta cuál de los cuadrados de Fibonacci se utiliza para la colocación de la reina (s), para el cálculo de la cobertura. Las reinas se colocan una a la vez en cada cuadro en ese mosaico cuadrado de Fibonacci en particular, y la cobertura total es la suma de la cobertura individual (única).

Por ejemplo, aquí hay una imagen de n = 8(el mismo mosaico que el anterior) y x = 4(correspondiente al f(4) = 3cuadrado, sombreado en azul). Al colocar una reina una a la vez en cada uno de esos nueve cuadrados azules, las reinas pueden (combinar) cubrir cada cuadrado que está sombreado en naranja. La cobertura total en este ejemplo es por lo tanto 309/714 = 43.28%.

Obviamente, en cualquier momento n = x, la cobertura será 100%(por ejemplo, con n=8y x=8, puede ver que cada cuadro en todo el tablero estará cubierto al menos una vez). A la inversa, con un adecuadamente grande ny x=1o x=2, la cobertura va a acercarse (pero nunca llegar a) 0%(por ejemplo, con n=8y x=1, la cobertura es un insignificante 88/714 = 12.32%).

Dados dos de estos números de entrada, debe generar el porcentaje de cobertura, con una precisión de dos decimales. Especifique cómo maneja su código el redondeo.

Reglas

• La entrada y la salida se pueden dar en cualquier formato conveniente , pero deben tener una precisión de dos decimales. Especifique cómo maneja su código el redondeo.
• Suponga que no hay otras piezas en el tablero o que interfieran con los movimientos.
• Un programa completo o una función son aceptables. Si es una función, puede devolver el resultado en lugar de imprimirlo.
• Si es posible, incluya un enlace a un entorno de prueba en línea para que otras personas puedan probar su código.
• Las lagunas estándar están prohibidas.
• Este es el código de golf, por lo que se aplican todas las reglas habituales de golf, y gana el código más corto (en bytes).

Ejemplos

n = 8, x = 4
43.28

n = 8, x = 8
100 or 100.00

n = 8, x = 1
12.32

n = 4, x = 1
66.67

n = 4, x = 2
60 or 60.00

n = 5, x = 3
75 or 75.00

n = 5, x = 1
47.5 or 47.50

VB.NET, (.NET 4.5), 1238 1229 bytes

-9 bytes gracias a @totallyhuman

Function A(n,x)
Dim g=New List(Of List(Of Long))
g.Add(New List(Of Long))
g(0).Add(1)
For i=2To n
Dim b=1
If i>2Then 
Dim w=0,y=1
b=w+y
For j=3To i
w=y
y=b
b=w+y
Next
End If
Select Case i Mod 4
Case 1
For j=1To b
Dim l=New List(Of Long)
For k=1To b
l.Add(i)
Next
g.Add(l)
Next
Case 2
For Each r In g
For j=1To b
r.Add(i)
Next
Next
Case 3
For j=1To b
g.Insert(0,New List(Of Long))
For k=1To b
g(0).Add(i)
Next
Next
Case 0
For Each r In g
For j=1To b
r.Insert(0,i)
Next
Next
End Select
Next
For i=0To g.Count-1
Dim c=g(i)
For j=0To c.Count-1
Dim e=c(j)
If e=x Then
For k=1To Math.Max(g.Count,g(0).Count)
If j-k>=0AndAlso c(j-k)<>x Then c(j-k)=0
If i-k>=0AndAlso g(i-k)(j)<>x Then g(i-k)(j)=0
If j+k<c.Count AndAlso c(j+k)<>x Then c(j+k)=0
If i+k<g.Count AndAlso g(i+k)(j)<>x Then g(i+k)(j)=0
If i-k>=0AndAlso j-k>=0AndAlso g(i-k)(j-k)<>x Then g(i-k)(j-k)=0
If i-k>=0AndAlso j+k<c.Count AndAlso g(i-k)(j+k)<>x Then g(i-k)(j+k)=0
If i+k<g.Count AndAlso j-k>=0AndAlso g(i+k)(j-k)<>x Then g(i+k)(j-k)=0
If i+k<g.Count AndAlso j+k<c.Count AndAlso g(i+k)(j+k)<>x Then g(i+k)(j+k)=0
Next
End If
Next
Next
Dim hits=0
For Each r In g
For Each c In r
If c=x Or c=0Then hits+=1
Next
Next
Return Math.Round(hits*100/(g.Count*g(0).Count),2)
End Function

Simulación del enunciado del problema. Comienzo creando la cuadrícula, recorriendo cada nuevo número de Fibonacci para aumentar el tamaño del cuadrado. Guardo el índice en cada celda, para que sea fácil encontrar a dónde irán las reinas en el siguiente paso.

Luego, encuentro cada celda que debería tener una reina y marco cada cuadrado amenazado con un cero. Me salto las celdas donde están las reinas para no tener que preocuparme por retroceder.

Al final, cuento las celdas que están despejadas, y las celdas con reinas, y luego las divido por el número total de espacios. Multiplique por 100 para obtener el porcentaje y redondee a los dos decimales más cercanos.

Python 2 , 524 499 bytes

def Q(n,x):
 global w,h,f;f,R,L=0,range,len
 for d in R(n):s=x-1==d;f=f or[[s]];w=L(f[0]);W,H=R(w),R(L(f));exec"for j in "+("W:f.append([s]*w)","f:\n\tfor k in H:j.append(s)","W:f.insert(0,[s]*w)","f:\n\tfor k in H:j.insert(0,s)","f:0")[d%4-(d==0)]
 w,h=L(f[0]),L(f);l=0,1,-1
 for Y in R(h):
	for X in R(w):exec("""def F(u,v,x,y):
 while(u==v==0)==0<=x<w!=0<=y<h:f[y][x]=1+(f[y][x]!=1);x+=u;y+=v
for s in l:
 for t in l:F(s,t,X,Y)""","")[f[Y][X]!=1]
 q=w*h;return(q-sum(j.count(0)for j in f))*100./q

Pruébalo en línea!

Definir una función que tome tanto el tamaño del mosaico ncomo el número cuadrado de fibonacci de la reina x. El porcentaje de salida se redondea a dos decimales (en el pie de página, donde se produce toda la salida).

fes una matriz bidimensional que contiene la información del tablero que se está iniciando 0. Luego, el tablero de ajedrez de Fibonacci se calcula y se rellena con reinas donde estarán las reinas. Esas reinas se mueven a todos los lugares donde se pueden mover; Todas las posiciones se cuentan e imprimen como un porcentaje de todo el tablero.

Mathematica 11.1, 336 bytes, basado en 1

R=Rectangle[#,+##]&;f=Fibonacci;o=Join@@Outer[##,1]&;r=RegionUnion;s=RegionMeasure;p[1]={0,0};p[i_]:=p[i-1]+{{-f@i,-f[i-2]},{0,-f@i},{f[i-1],0},{f[i-1]-f@i,f[i-1]}}[[i~Mod~4+1]];t[i_]:=r[R[p@#,f@#]&/@Range@i];k[n_,x_]:=Round[100s@RegionIntersection[r[R[#,f@x]&/@((#+p@x)&/@o[1##&,o[List,{-1,0,1},{-1,0,1}],Range[2f@n]])],t@i]/s@t@i,.01]

Uso: k[n, x]. Presta atención a que la función está basada en 1. El redondeo se logra medianteRound[100x,0.01]

Básicamente, p[i]es una función de determinar la posición de cada cuadrado. Y el área se calcula de nivel superior funciones como RegionIntersection, RegionUnion,RegionMeasure