[Question]
  [
One day you awake only to find yourself caught in an array. You try to just walk out of there, taking one index at the time, but it seems there are other rules:
The array is completely filled with natural numbers.
* If you find yourself on an index `n`, you go to the index `array[n]`, except:
* If you find yourself on an index `n` which is a prime number, you take `array[n]` steps back
Example:
You start on index `4`, in this array (start index is 0):
```
array = [1,4,5,6,8,10,14,15,2,2,4,5,7];
-----------------^ you are here
```
As the value of the field you are on is `8`, you go to the index `8` as the first step. The field you land on contains the value `2`. You then go to index `2` as your second step. As`2`is a prime number, you take 5 steps back, which is your third step. As there is no index `-3`, you successfully escaped the array in a total of 3 steps.
**Your task is:**
To write a program or function, which accepts an array and a start index as parameter, and outputs the amount of steps to escape the array. If you can't escape the array (e.g. `[2,0,2]` with start-index `2` => you constantly go from index `2` to `0`), output a falsy value. You may use one-based indexing or zero-based indexing, but please specify which you use. 
**Test cases**
Input: `[2,5,6,8,1,2,3], 3`
Output: `1`
Input: `[2, 0, 2], 2`
Output: `false`
Input: `[14,1,2,5,1,3,51,5,12,3,4,41,15,4,12,243,51,2,14,51,12,11], 5`;
Output: `6`
The shortest answer wins.
  
[Answer]
# Python, ~~161~~ 138 bytes
[Credits](https://codegolf.stackexchange.com/a/3133/48934) for factorial.
```
g=lambda x:0**x or x*g(x-1)
f=lambda a,i,n=0,l=[]:(i<0)+(i>=len(a))and n or(0 if i in l else f(a,[a[i],i-a[i]][i and-g(i-1)%i],n+1,l+[i]))
```
[Ideone it!](http://ideone.com/EjAD8T)
### How it works
[Wilson's theorem](https://en.wikipedia.org/wiki/Wilson%27s_theorem) is used for prime checking.
Loop detection by storing seen indices to an array (`l`) and checking whether current index is in `l`.
[Answer]
# Python, 107 bytes
```
import sympy
f=lambda a,i,n=0:0if n>len(a)else f(a,[a[i],i-a[i]][sympy.isprime(i)],n+1)if 0<=i<len(a)else n
```
Usage: `f(list, start)` ex: `f([2,5,6,8,1,2,3], 3)`
Returns `0` for loops (detected when `n > len(a)`)
[Answer]
# Matlab, 138 bytes
This a straighforward approach, using 1-based indices because Matlab uses 1-based indices by default. To count the number of steps we use a `for` loop counting from 1 to infinity(!). For the case were we cannot escape the array, we use a vector `v` to keep track of which entries we already visited. If we visit an entry twice, we know we are stuck in an unescapeable cycle. To see check whether we are outside of an array, we use the `try/catch` structure, which also catches out of bounds exceptions.
```
function r=f(a,i);v=a*0;v(i)=1;for k=1:Inf;if isprime(i);i=i-a(i);else;i=a(i);end;try;if v(i);r=0;break;end;v(i)=1;catch;r=k;break;end;end
```
[Answer]
## 05AB1E, 32 bytes
```
ï[U¯Xåi0,q}²gL<Xå_#X²XèXDˆpi-]¯g
```
**Explanation**
```
ï                                 # explicitly convert input to int
 [                            ]   # infinite loop
  U                               # store current index in X
   ¯Xåi0,q}                       # if we've already been at this index, print 0 and exit
           ²gL<Xå_#               # if we've escaped, break out of infinite loop
                   X²XèXDˆpi-     # else calculate new index
                               ¯g # print nr of indices traversed
```
[Try it online](http://05ab1e.tryitonline.net/#code=w69bVcKvWMOlaTAscX3CsmdMPFjDpV8jWMKyWMOoWETLhnBpLV3Cr2c&input=NQpbMTQsMSwyLDUsMSwzLDUxLDUsMTIsMyw0LDQxLDE1LDQsMTIsMjQzLDUxLDIsMTQsNTEsMTIsMTFd)
[Answer]
## Pyth, 31 Bytes
```
KlQ%tl-.u?}NUK?P_N-N@QN@QNKQEKK
```
[The test cases](http://pyth.herokuapp.com/?code=KlQ%25tl-.u%3F%7DNUK%3FP_N-N%40QN%40QNKQEKK&input=%5B2%2C5%2C6%2C8%2C1%2C2%2C3%5D%0A3&test_suite=1&test_suite_input=%5B2%2C5%2C6%2C8%2C1%2C2%2C3%5D%0A3%0A%5B2%2C+0%2C+2%5D%0A2%0A%5B14%2C1%2C2%2C5%2C1%2C3%2C51%2C5%2C12%2C3%2C4%2C41%2C15%2C4%2C12%2C243%2C51%2C2%2C14%2C51%2C12%2C11%5D%0A5&debug=1&input_size=2)
It uses zero to indicate a false value, the number of hops otherwise.
[Answer]
# JavaScript (ES6), 100
Index base 0. Note: this function modifies the input array
```
(a,p)=>eval("for(s=0;1/(q=a[p]);++s,p=p>1&&p%i||p==2?p-q:q)for(a[p]=NaN,i=1;p%++i&&i*i<p;);q==q&&s")
```
*Less golfed*
```
(a,p)=>
{
  for(s = 0; 
      1/ (q = a[p]); 
      ++s)
  {
    a[p] = NaN; // mark visited position with NaN to detect loops
    for(i = 1; p % ++i && i*i < p;); // prime check
    p = p > 1 && p % i || p == 2 ? p-q : q;
  }
  return q==q && s // return false if landed on NaN as NaN != NaN
}
```
**Test**
```
F=
(a,p)=>eval("for(s=0;1/(q=a[p]);++s,p=p>1&&p%i||p==2?p-q:q)for(a[p]=NaN,i=1;p%++i&&i*i<p;);q==q&&s")
;[
 [[2,5,6,8,1,2,3], 3, 1]
,[[2, 0, 2], 2, false]
,[[14,1,2,5,1,3,51,5,12,3,4,41,15,4,12,243,51,2,14,51,12,11], 5, 6]
].forEach(t=>{
  var [a,b,k]=t, i=a+' '+b,r=F(a,b)
  console.log(r==k?'OK':'KO',i+' -> '+r)
  
})  
```
[Answer]
# JAVA, ~~229~~ 218 Bytes
```
Object e(int[]a,int b){Stack i=new Stack();int s=0;for(;!(a.length<b|b<0);s++){if(i.contains(b))return 1>2;i.add(b);b=p(b)>0?b-a[b]:a[b];}return s;}int p(int i){for(int j=2;j<i/2;j++)if(i%j<1)return 0;return i<2?0:1;}
```
Thanks to Kevin, 11 bytes bites the dust.
[Answer]
# CJam, 44 bytes
Expects `index array` on the stack.
```
:G\{_G,,&{G=_L#)0{_L+:L;_mp3T?-F}?}L,?}:F~o@
```
[Try it online!](http://cjam.tryitonline.net/#code=NFsxIDQgNSA2IDggMTAgMTQgMTUgMiAyIDQgNSA3XTpHXHtfRywsJntHPV9MIykwe19MKzpMO19tcDNUPy1GfT99TCw_fTpGfm9A)
My first CJam answer, hence why it's so terrible and imperative...
```
:G\{_G,,&{G=_L#)0{_L+:L;_mp3T?-F}?}L,?}:F~o@
:G                                              Store the array as G
  \                                             Put the index first
   {                                  }:F~      The recursive F function
     G,,                                        Generate a 0..length(G) sequence
    _   &                            ?          Check that the index is contained
         {                        }             If so, then...
          G=                                    Get the value at the index
            _L#)                 ?              If the value is in L (`-1)` gives `0` which is falsy)
                0                               Return 0 (infinite loop)
                 {              }               Otherwise...
                  _L+:L;                        Store the value we're accessing in L (infinite loop check)
                        _mp3T?-                 Remove 3 if the number is prime
                               F                Then recursively call F
                                   L,           We escaped! Return the size of "L" (number of steps)
                                          o     Print the top value of the stack
                                           @    Tries to swap 3 elements, which will error out
```
(it is considered okay to crash after the correct output as printed, which is what the program here does)
[Answer]
## C, 121 bytes
Function `f` accepts array, starting index (0-based) and number of elements in the array, since there is no way how to test the end of an array in C (at least I don't know any).
```
p(n,i,z){return--i?p(n,i,z*i*i%n):z%n;}c;f(a,i,n)int*a;{return i<0||i/n?c:c++>n?0:i&&p(i,i,1)?f(a,i-a[i],n):f(a,a[i],n);}
```
Try it on [ideone!](http://ideone.com/77P4WW)
**Note:** `function p(n)` tests if `n` is prime or not. Credit for this goes to @Lynn and his answer for [Is this number a prime?](https://codegolf.stackexchange.com/questions/57617/is-this-number-a-prime)
[Answer]
## JavaScript, ~~121~~ 132 bytes
```
p=n=>t=i=>n%i&&n>i?t(i+1):(0<n&&n<=i?1:0),c=-1,a=>r=s=>(++c,0<=s&&s<a.length?(p(s)(2)?r(s-a[s]):0||([a[s],s]=[0,a[s]])[1]?r(s):0):c)
```
```
f=(p=n=>t=i=>n%i&&n>i?t(i+1):(0<n&&n<=i?1:0),c=-1,a=>r=s=>(++c,0<=s&&s<a.length?(p(s)(2)?r(s-a[s]):0||([a[s],s]=[0,a[s]])[1]?r(s):0):c));
let test_data = [[[1,4,5,6,8,10,14,15,2,2,4,5,7],4],
                 [[2,5,6,8,1,2,3],3],
                 [[2,0,2],2],
                 [[14,1,2,5,1,3,51,5,12,3,4,41,15,4,12,243,51,2,14,51,12,11],5]];
for (test of test_data) {
    c = -1;
    console.log(f(test[0])(test[1]));
}
```
edit 1: oops, missed the bit about returning number of steps. fix coming soonish.
edit 2: fixed
[Answer]
# Racket, ~~183~~ 156 bytes
Probably more bytes savable with further golfing, but that's it for me. :)
```
(require math)(define(e l i[v'()][g length])(cond[(memq i v)#f][(not(< -1 i(g l)))(g v)][else(e l((λ(a)(if(prime? i)(- i a)a))(list-ref l i))(cons i v))]))
```
Complete module with test suite with cleaner function:
```
#lang racket
(require math)
(define (e l i [v'()] [g length])
  (cond
    [(memq i v) #f]
    [(not (< -1 i (g l))) (g v)]
    [else (e l
             ((λ (a) (if (prime? i)
                         (- i a)
                         a))
              (list-ref l i))
             (cons i v))]))
(module+ test
  (require rackunit)
  (define escape-tests
    '((((2 5 6 8 1 2 3) 3) . 1)
      (((2 0 2) 2) . #f)
      (((14 1 2 5 1 3 51 5 12 3 4 41 15 4 12 243 51 2 14 51 12 11) 5) . 6)))
  (for ([t escape-tests])
    (check-equal? (apply e (car t)) (cdr t) (~a t))))
```
Run it like `raco test e.rkt`
Major kudos for @cat [discovering the undocumented `prime?` function](https://codegolf.stackexchange.com/a/77255/16190).
[Answer]
## Java, ~~163~~ 160 bytes
```
boolean p(int n){for(int i=2;i<n;)if(n%i++==0)return 0>1;return 1>0;}
int f(int[]a,int n){return n<0||n>=a.length?1:p(n)?n<a[n]?1:1+f(a,a[n-a[n]]):1+f(a,a[n]);}
```
`p(n)` is for prime testing, `f(a,n)` is for the escape function. Usage:
```
public static void main(String[] args) {
    int[] array = {14,1,2,5,1,3,51,5,12,3,4,41,15,4,12,243,51,2,14,51,12,11};
    System.out.println(f(array, 5));
}
```
Ungolfed version:
```
static boolean isPrime(int n) {
    for (int i = 2; i < n; i++) {
        if (n % i == 0) {
            return false;
        }
    }
    return true;
}
static int escape(int[] array, int n) {
    if (n < 0 || n >= array.length) {
        return 1;
    } else if (isPrime(n)) {
        if (n < array[n]) {
            return 1;
        } else {
            return 1 + escape(array, array[n - array[n]]);
        }
    } else {
        return 1 + escape(array, array[n]);
    }
}
```
[Answer]
# [Perl 6](http://perl6.org/), 85 bytes
```
->\n,\a{{.[+a].defined??0!!+$_}(lazy n,{.is-prime??$_- a[$_]!!a[$_]}...^!(0 <=* <a))}
```
Explanation:
```
lazy n, { .is-prime ?? $_ - a[$_] !! a[$_] } ...^ !(0 <= * < a)
```
This is a lazy sequence of the indices traversed according to the rule. If the index eventually exceeds the input array bounds (the `!(0 <= * < a)` condition), the sequence is finite; otherwise, the indices cycle infinitely.
That sequence is fed to the internal anonymous function:
```
{ .[+a].defined ?? 0 !! +$_ }
```
If the sequence is defined at the index given by the size of the input array, it must have entered an infinite cycle, so `0` is returned. Otherwise, the size of the sequence `+$_` is returned.
[Answer]
# [Perl 5](https://www.perl.org/), 107 + 1 (`-a`) = 108 bytes
```
for($i=<>;!$k{$i}++&&$i>=0&&$i<@F;$s++){$f=0|sqrt$i||2;1while$i%$f--;$i=$f?$F[$i]:$i-$F[$i]}say$k{$i}<2&&$s
```
[Try it online!](https://tio.run/##JYzBDoIwDIbvPsVMKtGQmXWyiwP0xM0nMB44sNhIBBmJMcCrO4tc@n1/2/xt1dUmBNd0W6Asze0aHgPQFMdRBJRnakZ6Liz4ON4N4DI1@lfXA42jtvi@U10BbcBJabkA3AmKK9DtCCQXm3z5WTpTzWU@BEwECi0Mz4MwOItmS0SCAg2To07@Jy34mckbxJX5Nm1PzdMHeTF7hSrI8gc "Perl 5 – Try It Online")
0-based list. Returns false (blank) if the list is unescapable.
]