Circle Maze Checker

¿Conoces esos juguetes de madera con pequeños rodamientos de bolas donde el objeto es moverse por el laberinto? Esto es un poco así. Dado un laberinto y una serie de movimientos, determine dónde termina la pelota.

El tablero se sostiene verticalmente, y la bola se mueve solo por gravedad cuando se gira el tablero. Cada "movimiento" es una rotación (en radianes).

El laberinto es simplemente paredes circulares concéntricas, con cada pared que tiene exactamente una abertura en el corredor exterior, similar a esto (suponga que esas paredes son círculos y no puntiagudas):

Como puede ver, la pelota comienza en el medio y está tratando de salir. La pelota se caerá instantáneamente tan pronto como se logre la orientación correcta, incluso si está en la mitad de una rotación. Una sola rotación puede hacer que la pelota caiga a través de múltiples aberturas. Por ejemplo, una rotación >= n * 2 * pies suficiente para escapar de cualquier laberinto.

Para los propósitos del juego, una pelota ubicada dentro de los 0.001radianes de la apertura se considera un "ajuste" y caerá al siguiente corredor.

Entrada:

La entrada está en dos partes:

• El laberinto está dado por un número entero que nrepresenta cuántas paredes / aberturas hay en el laberinto. Esto es seguido por nlíneas, con un número en cada una, que representa dónde está el pasaje al siguiente corredor.

• Los movimientos se dan como un número entero que mrepresenta cuántos movimientos se tomaron, seguidos (nuevamente en líneas separadas) por mrotaciones en sentido horario del tablero en radianes (negativo es en sentido antihorario).

Todas las posiciones de paso se dan como 0 rad = up, con radianes positivos en sentido horario.

Para la imagen de muestra anterior, la entrada puede verse así:

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

Salida: Muestra el número de corredor en el que termina la bola. Los corredores están indexados a cero, comenzando desde el centro, por lo que comienza 0. Si pasas por una abertura, estás en el pasillo 1. Si escapas de todo el laberinto, genera cualquier número entero>= n

Para la entrada de muestra, hay tres movimientos. El primero hará que la pelota caiga a través de dos aberturas. El segundo no encuentra una abertura, y el tercero encuentra una . La pelota ahora está en el corredor 3, por lo que la salida esperada es:

3

El comportamiento no está definido para entradas no válidas. La entrada válida está bien formada, con n >= 1y m >= 0.

La puntuación es el código estándar de golf, gana el menor número de bytes. Las lagunas estándar están prohibidas. La entrada no debe estar codificada, sino que puede tomarse de la entrada estándar, argumentos, consola, etc. La salida puede ser a la consola, archivo, lo que sea, simplemente hacer que la salida sea visible en algún lugar.

Perl, 211 191

Con nuevas líneas y sangría para facilitar la lectura:

$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$-

El número de movimientos en la entrada se descarta, el eof de stdin indica el final de los movimientos.

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}

EDITAR : Aquí hay un ejemplo animado que demuestra que este solucionador funciona: http://jsfiddle.net/F74AP/4/

La función debe llamarse pasando la cadena de entrada.
Aquí está la llamada del ejemplo dado por el OP:

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

Vuelve 3según lo previsto.