Qual è la probabilità che un cavaliere resti sulla scacchiera?


16

Date le dimensioni della scacchiera e la posizione iniziale del cavaliere, calcola la probabilità che dopo le kmosse il cavaliere si trovi all'interno della scacchiera.

Nota:

  • Il cavaliere compie tutte e 8 le mosse possibili con uguale probabilità.

  • Una volta che il cavaliere è fuori dalla scacchiera non può tornare dentro.

inserisci qui la descrizione dell'immagine

Ingresso

Gli input sono separati da virgola nel modulo:

l,k,x,y

dove lè la lunghezza e la larghezza della scacchiera, kè il numero di mosse che il cavaliere farà, xè la posizione x della posizione iniziale del cavaliere ed yè la posizione y della posizione iniziale del cavaliere. Nota che 0,0è l'angolo in basso a sinistra della tavola ed l-1,l-1è l'angolo in alto a destra della tavola.

Algoritmo:

Inizia con le coordinate iniziali del cavaliere. Fai tutte le mosse possibili per questa posizione e moltiplica queste mosse con la loro probabilità, per ogni mossa chiama ricorsivamente la funzione e continua questo processo fino a quando non viene soddisfatta la condizione finale. La condizione finale è se il cavaliere è fuori dalla scacchiera, in questo caso il ritorno 0, o il numero desiderato di mosse è esaurito, in questo caso il ritorno 1.

Come possiamo vedere, lo stato attuale della ricorsione dipende solo dalle coordinate correnti e dal numero di passi effettuati finora. Pertanto possiamo memorizzare queste informazioni in forma tabellare.

Credito

Questa sfida è originariamente tratta da un post sul blog di crazyforcode.com pubblicato sotto la licenza CC BY-NC-ND 2.5 IN . È stato leggermente modificato per renderlo un po 'più impegnativo.


14
Perché prescrivi un algoritmo esatto? Non sono sicuro che esista un'alternativa più elegante, ma richiedere un algoritmo specifico potrebbe potenzialmente impedire altri approcci intelligenti. Inoltre, non penso che sia necessario specificare il sistema di coordinate in modo così dettagliato - non influisce affatto sulla probabilità.
Martin Ender,

2
"Gli input sono separati da virgola nella forma: l, k, x, y" - quindi l'input è una stringa che dobbiamo analizzare? Non è accettabile scrivere una funzione che accetta 4 parametri?
Cristian Lupascu,

3
@Edi Non contrassegnare una risposta come "accettata" se non c'è stato tempo per altre persone di provare - contrassegnare qualcosa come accettato, quindi in pratica sta dicendo "La sfida è finita" - mentre la maggior parte del mondo probabilmente non ha ho anche avuto il tempo di guardarlo!
Sanchises,

3
@Edi Per favore, smetti di pubblicare sfide casuali che trovi sul web. Il plagio è malvisto dalla nostra comunità. Le sfide delle competizioni di programmazione in corso non hanno alcun interesse qui, dal momento che possono aiutare qualcuno a vincere questa competizione. E le sfide, che sono discusse in un post sul blog, come questa sfida a scacchi ( fonte originale ), non saranno accolte qui. Uno dei motivi è che la fonte originale potrebbe avere una sorta di copyright.
Jakube,

2
@Edi Ad esempio, la fonte di questa sfida consente la copia e la ridistribuzione, ma solo se si dà credito adeguato.
Jakube,

Risposte:


10

Pyth, 38 byte

M?smcgtGd8fq5sm^-Fk2C,TH^UhQ2G1g@Q1>Q2

Provalo online: dimostrazione

Spiegazione:

                                        implicit: Q = evaluated input
M                                       define a function g(G,H): //G=depth, H=current cell
                         UhQ              the list [0,1,...,Q[0]-1]
                        ^   2             Cartesian product, gives all cells
          f                               filter for numbers numbers T, which satisfy:
                    C,TH                    zip(T,H)
              m                             map the two pairs k to:
                -Fk                           their difference
               ^   2                          squared
             s                              sum (distance squared)
           q5                               == 5           
   m                                      map each valid cell d to:
     gtHd                                   g(G-1,d)
    c    8                                  divided by 8
  s                                       return sum
 ?                           G          if G > 0 else
                              1           return 1

                               g@Q1>Q2  call g(Q[1],Q[2:]) and print

Mi sembra che se creeremo linguaggi super concisi al solo scopo del golf, potremmo anche implementare l'algoritmo richiesto come primitivo.
MC0e,

3
@ mc0e No, sarebbe una scappatoia standard proibita. Vedi qui .
Jakube,

possiamo ottenere i pls di codice non golfati?
YaSh Chaudhary,

1
@YaShChaudhary Intendi la versione con 39 byte o la versione con 40 byte. :-P Temo che non sia mai esistita una versione veramente non giocata a golf. Ho scritto questo codice direttamente in Pyth e i programmi Pyth sono sempre brevi.
Jakube

@Jakube ohk np :)
YaSh Chaudhary,

8

Rubino 134

->l,m,x,y{!((r=0...l)===x&&r===y)?0:m<1?1:(0..7).map{|i|a,b=[1,2].rotate i[2]
P[l,m-1,x+a*(i[0]*2-1),y+b*(i[1]*2-1)]/8.0}.inject(:+)}

Provalo online: http://ideone.com/ZIjOmP

Il codice equivalente non golfato:

def probability_to_stay_on_board(board_size, move_count, x, y)
  range = 0...board_size
  return 0 unless range===x && range===y
  return 1 if move_count < 1

  possible_new_locations = (0..7).map do |i|
    dx, dy = [1,2].rotate i[2]
    dx *= i[0]*2-1
    dy *= i[1]*2-1

    [x+dx, y+dy]
  end

  possible_new_locations.map do |new_x, new_y| 
    probability_to_stay_on_board(board_size, move_count-1, new_x, new_y) / 8.0 
  end.inject :+
end

5

Haskell - 235

Implementa una funzione fcon parametril k x y

import Data.List
g[]=[]
g((a,b):r)=[(a+c,b+d)|(c,d)<-zip[-2,-1,1,2,-2,-1,1,2][1,2,-2,-1,-1,-2,2,1]]++g r
h _ 0 a=a
h l a b=h l(a-1)$filter(\(a,b)->(elem a[0..l])&&(elem b[0..l]))$g b
f l k x y=(sum$map(\x->1.0) (h l k [(x,y)]))/(8**k)

5

Matlab, 124 119

Implementa esattamente l'algoritmo descritto.

Sono stato in grado di accorciarlo di 5 byte con l'aiuto di @sanchises, grazie!

function s=c(l,k,x,y);m=zeros(5);m([2,4,10,20])=1/8;s(l,l)=0;s(l-y,x+1)=1;for i=1:k;s=conv2(s,m+m','s');end;s=sum(s(:))

Allargato:

function s=c(l,k,x,y);
    m=zeros(5);
    m([2,4,10,20])=1/8;
    s(l,l)=0;s(l-y,x+1)=1;
    for i=1:k;
        s=conv2(s,m+m','s');
    end;
    s=sum(s(:))

Vecchia versione

function s=c(l,k,x,y);
    m =zeros(5);m([1:3,5,8,10:12]*2)=1/8;
    s=zeros(l);
    s(l-y,x+1)=1;
    for i=1:k
        s=conv2(s,m,'s');
    end
    s=sum(s(:));

Un suggerimento: sè inizializzato da MATLAB, quindi puoi semplicemente farlo s(l,l)=0; Peccato che MATLAB non abbia fibonnaci come funzione integrata, per cui sarebbe un'ottima ottimizzazione m.
Sanchises,

Questo è un trucco super fantastico, grazie! Sto ancora cercando di trovare un modo più breve di creare muna decomposizione matriciale ...
flawr

Sì, lo stavo guardando anche da un po '. Forse qualche indicizzazione logica intelligente, ma non riesco a pensare a nulla. m+m'+fliplr(m+m')sembra essere un aumento del personale, e così sono tutte le altre mie opzioni.
Sanchises,

5

Mathematica - 137

q = # {1, 2} & /@ Tuples[{-1, 1}, 2]
q = Reverse /@ q~Union~q
g[l_, k_, x_, y_] :=

 Which[
  k < 1,
  1,

  !0 <= x < l || ! 0 <= y < l,
  0,

  0<1,
  Mean[g[l, k - 1, x + #[[1]], y + #[[2]]] & /@ q]
]

Uso:

g[5,5,1,2]

Produzione:

9/64

2

MATLAB - 106

function s=c(l,k,x,y);m(5,5)=0;m([2,4,10,20])=1/8;s=ones(l);for i=1:k;s=conv2(s,m+m','s');end;s=s(l-y,x+1)

Migliora la soluzione di @ flawr essendo più MATLAB-y.

Allargato:

function s=c(l,k,x,y)
    m(5,5)=0;
    m([2,4,10,20])=1/8;
    s=ones(l);
    for i=1:k
        s=conv2(s,m+m','s');
    end
    s=s(l-y,x+1)

1

> <> - 620 (senza contare gli spazi bianchi)

Lo stack iniziale dovrebbe essere l,k,x,y

{:a2*0p   v
vp0*3a*}:{<
>{1+&a3*0g}v                   >          >       >          >~~01-01-v             >          >       >          >~~01-01-v             >          >       >          >~~01-01-v             >          >       >          >~~01-01-v
           >&1-:&?!v>:@@:@@:0(?^:a2*0g1-)?^2-$:0(?^:a2*0g1-)?^1-      >}}$:@@:@@:0(?^:a2*0g1-)?^2-$:0(?^:a2*0g1-)?^1+      >}}$:@@:@@:0(?^:a2*0g1-)?^2+$:0(?^:a2*0g1-)?^1-      >}}$:@@:@@:0(?^:a2*0g1-)?^2+$:0(?^:a2*0g1-)?^1+      >}}$:@@:@v
v1         ^}       ^!?=g0*3a:~~}}<      +2v?)-1g0*2a:v?(0:$+1v?)-1g0*2a:v?(0:@@:@@:$}}<      -2v?)-1g0*2a:v?(0:$+1v?)-1g0*2a:v?(0:@@:@@:$}}<      +2v?)-1g0*2a:v?(0:$-1v?)-1g0*2a:v?(0:@@:@@:$}}<-2      v?)-1g0*2a:v?(0:$-1v?)-1g0*2a:v?(0:@<
>a3*0g=   ?^\      &              ^-10-10~~<          <       <          <             ^-10-10~~<          <       <          <             ^-10-10~~<          <       <          <             ^-10-10~~<          <       <          <
\         :{/      
v                  >~{~l2,&0
>@:0(?v:a2*0g1-)?v$:0(?v:a2*0g1-)?v1>@~~+l1=?v
      >          >     >          >0^        >&,n;

Provalo

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.