Circle Maze Checker

Vous connaissez ces jouets en bois avec de petits roulements à billes où l'objet est de se déplacer dans le labyrinthe? C'est un peu comme ça. Étant donné un labyrinthe et une série de mouvements, déterminez où la balle finit.

La planche est tenue verticalement et la balle ne se déplace que par gravité lorsque la planche est tournée. Chaque "mouvement" est une rotation (en radians).

Le labyrinthe est simplement des murs circulaires concentriques, chaque mur ayant exactement une ouverture dans le couloir extérieur, similaire à cela (supposez que ces murs sont des cercles et non pointus):

Comme vous pouvez le voir, le ballon commence au milieu et essaie de sortir. La balle passera instantanément à travers dès que l'orientation correcte est atteinte, même si elle est à mi-chemin d'une rotation. Une seule rotation peut faire tomber le ballon par plusieurs ouvertures. Par exemple, une rotation >= n * 2 * pisuffit pour échapper à tout labyrinthe.

Aux fins du jeu, une balle située à moins de 0.001radians de l'ouverture est considérée comme «en forme» et passera dans le couloir suivant.

Contribution:

L'entrée est en deux parties:

• Le labyrinthe est donné par un entier nreprésentant le nombre de murs / ouvertures dans le labyrinthe. Ceci est suivi de nlignes, avec un numéro sur chacune, indiquant où se trouve le passage vers le couloir suivant.

• Les mouvements sont donnés sous forme d'entier mreprésentant le nombre de mouvements effectués, suivis (à nouveau sur des lignes distinctes) par des mrotations dans le sens horaire de la planche en radians (le négatif est dans le sens inverse des aiguilles d'une montre).

Toutes les positions de passage sont données par 0 rad = up, avec des radians positifs dans le sens horaire.

Pour l'exemple d'image ci-dessus, l'entrée peut ressembler à ceci:

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

Sortie: affichez le numéro du couloir dans lequel se termine la balle. Les couloirs sont indexés à zéro, en partant du centre, vous commencez donc 0. Si vous passez par une ouverture, vous êtes dans le couloir 1. Si vous échappez à tout le labyrinthe, sortez n'importe quel entier>= n

Pour l'entrée d'échantillon, il y a trois mouvements. Le premier fera tomber le ballon par deux ouvertures. Le second ne trouve pas d'ouverture et le troisième en trouve une . La balle est maintenant dans le couloir 3, donc la sortie attendue est:

3

Le comportement n'est pas défini pour une entrée non valide. Une entrée valide est bien formée, avec n >= 1et m >= 0.

La notation est le golf à code standard, le plus petit nombre d'octets gagne. Les failles standard sont interdites. L'entrée ne doit pas être codée en dur, mais peut être prise à partir de l'entrée standard, des arguments, de la console, etc. La sortie peut être vers une console, un fichier, peu importe, juste la rendre quelque part visible.

Perl, 211 191

Avec des nouvelles lignes et un retrait pour la lisibilité:

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

Le nombre de coups dans l'entrée est rejeté, la fin de stdin indique la fin des coups.

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 : Voici un exemple animé prouvant que ce solveur fonctionne: http://jsfiddle.net/F74AP/4/

La fonction doit être appelée en passant la chaîne d'entrée.
Voici l'appel de l'exemple donné par l'OP:

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

Il revient 3comme prévu.