(ispirato dalla risposta di Helka al mio abbinamento casuale di tag "scacchi" e "Fibonacci" in chat)

Fibonacci

I numeri di Fibonacci sono una delle sequenze più note in matematica, dove ogni numero è composto sommando i due numeri precedenti. Di seguito è una definizione della sequenza indicizzata zero:

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

Ciò risulta nella sequenza 0, 1, 1, 2, 3, 5, 8, 13, 21, ...( collegamento OEIS ). In questa sfida, ci concentreremo solo sui valori strettamente positivi (quindi 1, 1, 2, 3, ...) e puoi scegliere l'indicizzazione zero o l'indicizzazione uno, ma ti preghiamo di indicare quale nel tuo invio.

I numeri di Fibonacci possono essere usati per una piastrellatura del piano, usando quadrati f(n)di dimensioni successive e allineando i loro bordi. La piastrellatura viene eseguita in senso antiorario, posizionando i quadrati nello schema "destra-su-sinistra-giù" dal quadrato corrente. Un esempio di questa piastrellatura parziale per f(8)=21, con il quadrato iniziale evidenziato in blu, è il seguente:

Si può vedere il f(1)=1come la casella di partenza (evidenziato in blu), la f(2)=1piazza posta alla destra di esso, il f(3)=2quadrato posto in su da lì, il f(4)=3quadrato che si trova a sinistra , e così via. La prossima piazza sarebbe f(9)=21+13=34e sarebbe posizionata in basso. Questo è il metodo di piastrellatura parziale che useremo in questa sfida.

Le regine

Nel gioco degli scacchi , il pezzo più potente è la regina perché può muovere qualsiasi numero di spazi in orizzontale, verticale o diagonale. Nel diagramma in basso, i quadrati con un cerchio nero mostrano dove la regina può muoversi:

Definiremo il termine copertura come

La percentuale di quadrati in cui la regina può spostarsi rispetto al numero totale di quadrati, data la particolare posizione della regina su una tavola vuota e inclusa la posizione iniziale della regina.

Per l'esempio precedente, la copertura della regina è 28/64 = 43.75%. Se la regina fosse nella h8piazza in alto a destra , la copertura sarebbe 22/64 = 34.375%. Se la regina fosse presente e7, la copertura sarebbe stata 24/64 = 37.5%.

La sfida

Utilizzeremo la piastrellatura di Fibonacci dimostrata sopra come nostra scacchiera per questa sfida. Ti verranno dati due numeri interi positivi come input ne x:

• Il nrappresenta quanto è grande la piastrellatura. La piastrellatura di esempio sopra, con il 21quadrato a sinistra, è una tavola di dimensioni da n = 8allora f(8) = 21(quando indicizzata con zero).
• La xrappresenta, che delle piazze di Fibonacci viene utilizzato per il posizionamento della regina (s), per il calcolo della copertura. Le regine sono posizionate una alla volta su ogni quadrato in quella particolare tessera quadrata di Fibonacci, e la copertura totale è la somma della copertura individuale (unica).

Ad esempio, ecco un'immagine di n = 8(la stessa piastrellatura di cui sopra) e x = 4(corrispondente al f(4) = 3quadrato, blu sfumato). Posizionando una regina alla volta in ciascuno di quei nove quadrati blu, le regine possono (combinare) coprire ogni quadrato che è ombreggiato in arancione. La copertura totale in questo esempio è quindi 309/714 = 43.28%.

Ovviamente, ogni volta che n = xla copertura sarà 100%(ad esempio, con n=8e x=8, puoi vedere che ogni quadrato dell'intero tabellone sarà coperto almeno una volta). Al contrario, con una copertura sufficientemente ampia ne x=1o x=2, la copertura si avvicinerà (ma non raggiungerà mai) 0%(ad esempio, con n=8e x=1, la copertura è irrisoria 88/714 = 12.32%).

Dati due di tali numeri di input, è necessario generare la percentuale di copertura, accurata con due decimali. Specifica come il tuo codice gestisce l'arrotondamento.

Regole

• L'input e l'output possono essere forniti in qualsiasi formato conveniente , ma devono essere precisi al secondo decimale. Specifica come il tuo codice gestisce l'arrotondamento.
• Supponiamo che non ci siano altri pezzi sul tabellone o che interferiscano in altro modo con le mosse.
• È accettabile un programma completo o una funzione. Se una funzione, è possibile restituire l'output anziché stamparlo.
• Se possibile, includi un collegamento a un ambiente di test online in modo che altre persone possano provare il tuo codice!
• Sono vietate le scappatoie standard .
• Si tratta di code-golf quindi si applicano tutte le normali regole del golf e vince il codice più breve (in byte).

Esempi

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 byte

-9 byte grazie 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

Simulazione della dichiarazione del problema. Comincio creando la griglia, eseguendo il ciclo attraverso ogni nuovo numero di fibonacci per aumentare la dimensione quadrata. Conservo l'indice in ogni cella, in modo che sia facile trovare dove andranno le regine nel passaggio successivo.

Quindi, trovo tutte le celle che dovrebbero contenere una regina e segnano ogni quadrato minacciato con uno zero. Salto le celle in cui si trovano le regine in modo da non dovermi preoccupare di tornare indietro.

Alla fine, conto le celle che vengono eliminate e le celle con le regine, quindi le divido per il numero totale di spazi. Moltiplicare per 100 per ottenere la percentuale e arrotondare alle due decimali più vicine.

Python 2 , 524 499 byte

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

Provalo online!

Definizione di una funzione che accetta sia la dimensione della piastrellatura sia il nnumero quadrato di fibonacci della regina x. La percentuale di uscita viene arrotondata per difetto a due cifre decimali (nel piè di pagina, dove sta avvenendo tutto l'output).

fè un array bidimensionale contenente le informazioni sulla scheda da avviare 0. Quindi, la scacchiera fibonacci viene calcolata e popolata con regine dove devono trovarsi le regine. Quelle regine vengono quindi spostate in ogni luogo in cui possono essere spostate; tutte le posizioni vengono contate e stampate come percentuale dell'intera scheda.

Mathematica 11.1, 336 byte, 1 basato

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]. Prestare attenzione al fatto che la funzione è basata su 1. L'arrotondamento è realizzato daRound[100x,0.01]

Fondamentalmente, p[i]è una funzione per determinare la posizione di ciascun quadrato. E la zona è calcolato in alto a livello di funzioni come RegionIntersection, RegionUnion,RegionMeasure