Circle Maze Checker

Sai quei giocattoli di legno con piccoli cuscinetti a sfera in cui l'oggetto deve muoversi nel labirinto? Questo è un po 'così. Dato un labirinto e una serie di mosse, determinare dove finisce la palla.

La tavola è tenuta in verticale e la palla si muove solo per gravità quando la tavola viene ruotata. Ogni "mossa" è una rotazione (in radianti).

Il labirinto è semplicemente pareti circolari concentriche, con ogni parete che ha esattamente un'apertura nel corridoio esterno, simile a questo (supponiamo che quelle pareti siano cerchi e non appuntite):

Come puoi vedere, la palla inizia nel mezzo e sta cercando di uscire. La palla cadrà all'istante non appena sarà raggiunto l'orientamento corretto, anche se è a metà di una rotazione. Una singola rotazione può far cadere la palla attraverso più aperture. Ad esempio, una rotazione >= n * 2 * piè sufficiente per sfuggire a qualsiasi labirinto.

Ai fini del gioco, una palla situata all'interno dei 0.001radianti dell'apertura è considerata un "adattamento" e passerà attraverso il corridoio successivo.

Ingresso:

L'input è suddiviso in due parti:

• Il labirinto è dato da un numero intero che nrappresenta il numero di pareti / aperture presenti nel labirinto. Questo è seguito da nlinee, con un numero su ciascuna, che rappresentano dove si trova il passaggio al corridoio successivo.

• Le mosse sono indicate come un numero intero che mrappresenta il numero di mosse eseguite, seguite (sempre su linee separate) da mrotazioni orarie della scheda in radianti (il negativo è in senso antiorario).

Tutte le posizioni di passaggio sono indicate come 0 rad = up, con radianti positivi che vanno in senso orario.

Per l'immagine di esempio sopra, l'input potrebbe essere simile al seguente:

7                        // 7 openings
0
0.785398163
3.14159265
1.74532925
4.71238898
4.01425728
0
3                        // 3 moves
-3.92699082
3.14159265
0.81245687

Uscita: emette il numero del corridoio in cui finisce la palla. I corridoi sono indicizzati a zero, a partire dal centro, quindi si inizia 0. Se passi attraverso un'apertura, sei nel corridoio 1. Se si esce dall'intero labirinto, emettere un numero intero>= n

Per l'input del campione, ci sono tre mosse. Il primo farà cadere la palla attraverso due aperture. Il secondo non trova un'apertura e il terzo ne trova una . La palla è ora in corridoio 3, quindi l'output previsto è:

3

Il comportamento non è definito per input non valido. L'input valido è ben formato, con n >= 1e m >= 0.

Il punteggio è un codice golf standard, il numero più basso di byte vince. Sono vietate le scappatoie standard . L'input non deve essere hardcoded, ma può essere preso da input standard, argomenti, console, ecc. L'output può essere su console, file, qualunque cosa, semplicemente renderlo visibile da qualche parte.

Perl, 211 191

Con newline e rientro per la leggibilità:

$p=atan2 0,-1;
@n=map~~<>,1..<>;
<>;
while(<>){
    $_=atan2(sin,cos)for@n;
    $y=abs($n[$-]+$_)<$p-.001
        ?$_
        :($_<=>0)*$p-$n[$-];
    $_+=$y for@n;
    $p-.001<abs$n[$-]&&++$-==@n&&last;
    $_-=$y;
    .001<abs&&redo
}
print$-

Il numero di mosse nell'input viene scartato, la griglia di stdin indica la fine delle mosse.

JavaScript 200

function f(i){with(Math)for(m=i.split('\n'),o=m.slice(1,t=+m[0]+1),m=m.slice(t+1),c=PI,p=2*c,r=0,s=1e-3;m.length;c%=p)abs(c-o[r])<s?r++:abs(t=m[0])<s?m.shift(c+=t):(b=t<0?-s:s,c+=p-b,m[0]-=b);return r}

EDIT : Ecco un esempio animato che dimostra che questo risolutore funziona: http://jsfiddle.net/F74AP/4/

La funzione deve essere chiamata passando la stringa di input.
Ecco il richiamo dell'esempio dato dall'OP:

f("7\n0\n0.785398163\n3.14159265\n1.74532925\n4.71238898\n4.01425728\n0\n3\n-3.92699082\n3.14159265\n0.81245687");

Ritorna 3come previsto.