어느 날 당신은 자신이 배열에 잡힌 것을 찾기 위해 깨어 있습니다. 한 번에 하나의 색인을 취해 나 가려고하지만 다른 규칙이있는 것 같습니다.

배열은 자연수로 완전히 채워집니다.

• index 자신을 찾으면 n다음을 array[n]제외하고 index로 이동합니다 .
• n소수 인 인덱스에 자신을 찾으면 array[n]뒤로 물러납니다.

예 : 4이 배열 에서 index로 시작합니다 (시작 색인은 0 임).

array = [1,4,5,6,8,10,14,15,2,2,4,5,7];
-----------------^ you are here

현재 필드의 값이 8이므로 8첫 번째 단계로 색인 으로 이동합니다 . 착륙하는 필드에는 값이 포함되어 있습니다 2. 그런 다음 2두 번째 단계 로 색인 으로 이동 하십시오. 으로 2소수이며, 당신은 세 번째 단계 인 다시 5 조치를 취합니다. index가 없으므로 -3총 3 단계로 배열을 이스케이프했습니다.

당신의 임무는 :

배열 및 시작 색인을 매개 변수로 승인하고 배열을 이스케이프하기위한 단계 수를 출력하는 프로그램 또는 함수를 작성합니다. 배열을 이스케이프 할 수없는 경우 (예 : [2,0,2]start-index 2=>를 사용하면 지속적으로 index 2에서으로 이동 0) 잘못된 값을 출력하십시오. 1 기반 색인화 또는 0 기반 색인화를 사용할 수 있지만 사용할 색인을 지정하십시오.

테스트 사례

입력: [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

가장 짧은 답변이 이깁니다.

피쓰, 31 바이트

KlQ%tl-.u?}NUK?P_N-N@QN@QNKQEKK

테스트 사례

0을 사용하여 잘못된 값을 나타내며 그렇지 않은 경우 홉 수를 나타냅니다.

파이썬, 161138 바이트

계승에 대한 크레딧 .

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]))

무시 했어!

작동 원리

윌슨 정리 는 프라임 검사에 사용됩니다.

보이는 인덱스를 배열에 저장 l하고 현재 인덱스가 있는지 확인 하여 루프 감지 l.

파이썬, 107 바이트

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

사용법 : f(list, start)예 :f([2,5,6,8,1,2,3], 3)

반환 0for 루프 (때 감지 n > len(a))

Matlab, 138 바이트

Matlab은 기본적으로 1 기반 인덱스를 사용하기 때문에 1 기반 인덱스를 사용하는이 방법은 간단합니다. 걸음 수를 계산하기 위해 for1에서 무한대 (!)까지 의 루프 계산을 사용합니다 . 우리는 배열을 이스케이프 처리 할 수없는 경우 v를 위해 벡터 를 사용하여 이미 방문한 항목을 추적합니다. 우리가 입장을 두 번 방문하면 우리는 탈출 할 수없는주기에 갇혀 있음을 알 수 있습니다. 우리가 배열 외부에 있는지 확인하기 위해 try/catch구조를 사용합니다.이 구조는 범위를 벗어난 예외를 포착합니다.

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

05AB1E, 32 바이트

ï[U¯Xåi0,q}²gL<Xå_#X²XèXDˆpi-]¯g

설명

ï                                 # 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

온라인으로 사용해보십시오

자바 스크립트 (ES6), 100

색인 기준 0. 참고 :이 함수는 입력 배열을 수정합니다.

(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")

덜 골프

(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
}

테스트

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)
  
})  

자바, 229218 바이트

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;}

Kevin 덕분에 11 바이트가 먼지를 물었습니다.

CJam, 44 바이트

index array스택에 예상 됩니다.

:G\{_G,,&{G=_L#)0{_L+:L;_mp3T?-F}?}L,?}:F~o@

온라인으로 사용해보십시오!

내 첫 번째 CJam 답변, 왜 그렇게 끔찍하고 명령 적인지 ...

: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

(정확한 출력이 인쇄 된 후에 충돌하는 것이 괜찮습니다. 여기에서 프로그램이 수행하는 방식입니다)

C, 121 바이트

fC에서 배열의 끝을 테스트하는 방법이 없기 때문에 함수 는 배열, 시작 색인 (0 기반) 및 배열의 ​​요소 수를 받아들입니다 (적어도 나는 모른다).

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);}

아이디어로 사용해보십시오 !

참고 : 소수인지 function p(n)테스트합니다 n. 이것에 대한 크레딧은 @Lynn에 간다 .

자바 스크립트, 121 132 바이트

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]));
}

편집 1 : 죄송합니다. 반복 횟수에 대한 정보가 누락되었습니다. 곧 고쳐집니다.

편집 2 : 고정

라켓, 183 156 바이트

더 많은 골프를 타면 더 많은 바이트를 절약 할 수 있지만 그게 다입니다. :)

(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))]))

더 깨끗한 기능을 갖춘 테스트 스위트가있는 완전한 모듈 :

#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))))

다음과 같이 실행 raco test e.rkt

문서화되지 않은 prime?기능을 발견하는 @cat에 대한 주요한 논점 .

자바, 163160 바이트

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)프라임 테스트 f(a,n)용이며 이스케이프 기능 용입니다. 용법:

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));
}

언 골프 버전 :

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]);
    }
}

펄 6 , 85 바이트

->\n,\a{{.[+a].defined??0!!+$_}(lazy n,{.is-prime??$_- a[$_]!!a[$_]}...^!(0 <=* <a))}

설명:

lazy n, { .is-prime ?? $_ - a[$_] !! a[$_] } ...^ !(0 <= * < a)

이것은 규칙에 따라 순회되는 인덱스의 게으른 시퀀스입니다. 인덱스가 결국 입력 배열 범위 ( !(0 <= * < a)조건)를 초과 하면 시퀀스는 유한합니다. 그렇지 않으면, 인덱스는 무한정 순환합니다.

이 시퀀스는 내부 익명 함수로 전달됩니다.

{ .[+a].defined ?? 0 !! +$_ }

입력 배열의 크기에 의해 주어진 색인에서 순서가 정의되면, 무한주기를 입력 했어야하므로 0리턴됩니다. 그렇지 않으면 시퀀스의 크기 +$_가 반환됩니다.

Perl 5 , 107 + 1 ( -a) = 108 바이트

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

온라인으로 사용해보십시오!

0 기반 목록. 목록을 이스케이프 할 수 없으면 false (공백)를 반환합니다.