포인터가 배열의 특정 위치를 가리키는 길이 의 배열 가 있다고 가정 합니다. " 포인터 점프 " 프로세스는 포인터가 가리키는 위치에 모든 포인터를 설정합니다.$\texttt{ps}$$n$

이 문제를 해결하기 위해 포인터는 배열 요소의 인덱스 (0부터 시작)이며 배열의 모든 요소는 보다 크거나 같고 보다 작습니다 . 이 표기법을 사용하여 다음과 같이 프로세스를 공식화 할 수 있습니다.$0$$n$

for i = 0..(n-1) {
  ps[i] = ps[ps[i]]
}

이것은 (이 도전 과제에서) 포인터가 순차적으로 순서대로 업데이트된다는 것을 의미합니다 (즉, 먼저 낮은 지수).

예

예제를 살펴 보겠습니다 .$\texttt{ps = [2,1,4,1,3,2]}$

$$\texttt{i = 0}: \text{the element at position }\texttt{ps[0] = 2}\text{ points to }\texttt{4} \\ \to \texttt{ps = [4,1,4,1,3,2]} \\ \texttt{i = 1}: \text{the element at position }\texttt{ps[1] = 1}\text{ points to }\texttt{1} \\ \to \texttt{ps = [4,1,4,1,3,2]} \\ \texttt{i = 2}: \text{the element at position }\texttt{ps[2] = 4}\text{ points to }\texttt{3} \\ \to \texttt{ps = [4,1,3,1,3,2]} \\ \texttt{i = 3}: \text{the element at position }\texttt{ps[3] = 1}\text{ points to }\texttt{1} \\ \to \texttt{ps = [4,1,3,1,3,2]} \\ \texttt{i = 4}: \text{the element at position }\texttt{ps[4] = 3}\text{ points to }\texttt{1} \\ \to \texttt{ps = [4,1,3,1,1,2]} \\ \texttt{i = 5}: \text{the element at position }\texttt{ps[5] = 2}\text{ points to }\texttt{3} \\ \to \texttt{ps = [4,1,3,1,1,3]}$$

따라서 " 포인터 점프 "를 한 번 반복 하면 배열을 얻게 됩니다.$\texttt{[4,1,3,1,1,3]}$

도전

인덱스 출력을 가진 배열이 주어지면 배열이 더 이상 변경되지 않을 때까지 위에서 설명한 포인터 점프를 반복하여 얻은 배열.

규칙

프로그램 / 함수는 동일한 유형, 목록 / 벡터 / 배열 등을 가져 와서 출력합니다.

• 비어 있지 않은 것으로 보장되고
• 항목 만 포함하도록 보장됩니다 .$0 \leq p < n$

변형 : 당신은 선택할 수 있습니다

• 1 기반 인덱싱을 사용하거나
• 실제 포인터를 사용하십시오.

그러나 당신은 당신의 제출에 이것을 언급해야합니다.

테스트 사례

[0] → [0]
[1,0] → [0,0]
[1,2,3,4,0] → [2,2,2,2,2]
[0,1,1,1,0,3] → [0,1,1,1,0,1]
[4,1,3,0,3,2] → [3,1,3,3,3,3]
[5,1,2,0,4,5,6] → [5,1,2,5,4,5,6]
[9,9,9,2,5,4,4,5,8,1,0,0] → [1,1,1,1,4,4,4,4,8,1,1,1]

자바 스크립트, 36 바이트

원래 입력 배열을 수정합니다.

a=>a.map(_=>a.map((x,y)=>a[y]=a[x]))

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

하스켈, 56 바이트

foldr(\_->([]#))=<<id
x#a@(b:c)=(x++[(x++a)!!b])#c
x#_=x

Haskell 및 전체 업데이트는 적합하지 않습니다.

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

파이썬 2 , 53 바이트

def f(l):L=len(l);i=0;exec'l[i]=l[l[i]];i=-~i%L;'*L*L

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

HyperNeutrino 덕분에 -6 .

l결과에 따라 변경 됩니다.

C ++ 14 (gcc) , 61 바이트

명명되지 않은 일반 람다. 와 같은 순차적 컨테이너가 필요합니다 std::vector.

[](auto&c){auto d=c;do{d=c;for(auto&x:c)x=c[x];}while(d!=c);}

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

스위프트 , 68 53 바이트

{a in for _ in a{var i=0;a.forEach{a[i]=a[$0];i+=1}}}

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

BMO 덕분에 -15

자바 스크립트 (ES6), 41 바이트

f=a=>a+''==a.map((x,i)=>a[i]=a[x])?a:f(a)

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

05AB1E (레거시) , 8 바이트

ΔDvDyèNǝ

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

설명

Δ          # apply until the top of the stack stops changing
 D         # duplicate current list
  v        # for each (element y, index N) in the list
   Dyè     # get the element at index y
      Nǝ   # and insert it at index N

05AB1E , 14 바이트

[D©vDyèNǝ}D®Q#

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

apt, 15 13 7 바이트

원래 입력 배열을 수정합니다.

££hYXgU

시도해보십시오 (추가 바이트는 수정 된 입력을 콘솔에 쓰는 것입니다)

££hYXgU
£           :Map
 £          :  Map each X at index Y
  hY        :    Replace the element at index Y
    XgU     :    With the element at index X

자바 8, 105 54 바이트

a->{for(int l=a.length,i=0;i<l*l;)a[i%l]=a[a[i++%l]];}

바이트를 절약하기 위해 새로운 것을 반환하는 대신 입력 배열을 수정합니다.

$length^2$

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

설명:

a->{                // Method with integer-array parameter and no return-type
  int l=a.length,   //  Length of the input-array
  i=0;i<l*l;)       //  Loop `i` in the range [0, length squared):
    a[i%l]=         //   Set the (`i` modulo-length)'th item in the array to:
      a[            //    The `p`'th value of the input-array,
        a[i++%l]];} //    where `p` is the (`i` modulo-length)'th value of the array

Japt , 17 바이트

®
£hYUgX
eV ?U:ß

모든 테스트 사례를 시도하십시오

이것은 더 짧아야하는 것처럼 느껴지지만 불행히도 각 단계마다 원본을 수정하지 않고 원본에 액세스 UmgU하기 때문에 초기 생각이 작동하지 않습니다 . 다른 구성 요소를 적절하게 유지하려면 몇 바이트의 비용이 필요합니다.gU

설명:

           #Blank line preserves input in U long enough for the next line

®          #Copy U into V to preserve its original value

£hY        #Modify U in-place by replacing each element X with...
   UgX     #The value from the current U at the index X

eV ?U      #If the modified U is identical to the copy V, output it
     :ß    #Otherwise start again with the modified U as the new input

C (클랑) , 32 비트, 49 44 바이트

i;f(**p,n){for(i=0;i<n*n;)p[i++%n]=*p[i%n];}

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

포인터를 사용합니다.

정수가있는 50 45 바이트 :

i;f(*p,n){for(i=0;i<n*n;)p[i++%n]=p[p[i%n]];}

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

루비 , 37 34 바이트

->a{a.size.times{a.map!{|x|a[x]}}}

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

입력 배열을 내부에서 수정하여 반환합니다.

빨강 , 63 바이트

func[b][loop(l: length? b)* l[repeat i l[b/:i: b/(1 + b/:i)]]b]

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

배열을 제자리에 수정

R , 60 58 바이트

규칙을 읽는 @digEmAll 덕분에 -2 바이트.

function(x,n=sum(x|1)){for(i in rep(1:n,n))x[i]=x[x[i]];x}

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

1- 색인.

n 입력 배열의 길이입니다.

rep(1:n,n)복제 된 1:n n시간 (예를 들어 n=3 => 1,2,3,1,2,3,1,2,3)

배열 n시간을 반복합니다. 그때까지 확실히 n-1 시간이 끝날 때까지 꾸준한 상태가 달성 될 것입니다. 증거는 독자에게 맡겨져 있습니다.

공통 리스프, 59 58 바이트

(lambda(a)(dolist(j a)(map-into a(lambda(x)(elt a x))a))a)

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

클린 , 80 바이트

import StdEnv

limit o iterate\b=foldl(\l i=updateAt i(l!!(l!!i))l)b(indexList b)

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

클로저 , 136 바이트

(defn j[a](let[f(fn[a](loop[i 0 a a](if(= i(count a))a(recur(inc i)(assoc a i(a(a i)))))))](loop[p nil a a](if(= p a)a(recur a(f a))))))

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

펄 5, 35 34 26 바이트

반복 횟수가 최대 일 때 수렴에 도달한다는 사실을 사용

$_=$F[$_]for@F x@F;$_="@F"

26 바이트

$_=$F[$_]for@F;/@F/ or$_="@F",redo

34 바이트

$_=$F[$_]for@F;$_="@F",redo if!/@F/

35 바이트

클로저 , 88 바이트

#(reduce(fn[x i](assoc x i(get x(get x i))))%(flatten(repeat(count %)(range(count %)))))

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

숯 , 16 바이트

ＦθＦＬθ§≔θκ§θ§θκＩθ

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. 슬프게도 모든 일반적인 매핑 함수는 배열의 복사본에서만 작동하므로 결과적으로 요소를 뛰어 넘기지 않고 그대로 퍼뜨 리므로 코드가 모든 것을 수동으로 수행해야합니다. 설명:

Ｆθ

각 요소에 대해 내부 루프를 한 번 반복하십시오. 이렇게하면 결과가 안정화됩니다.

ＦＬθ

배열 인덱스를 반복합니다.

§≔θκ§θ§θκ

현재 색인에서 배열 요소를 가져 와서 배열로 색인화하고 현재 요소를 해당 값으로 바꿉니다.

Ｉθ

요소를 문자열로 캐스트하고 각 행을 내재적으로 인쇄하십시오.

F #, 74 73 바이트

fun(c:'a[])->let l=c.Length in(for i in 0..l*l do c.[i%l]<-c.[c.[i%l]]);c

특별한 것은 없습니다. 다른 답변에서 볼 수있는 계수 아이디어를 사용합니다.

K, 27 바이트

{{@[x;y;:;x x y]}/[x;!#x]}/

• {..}/ arg에 람다 {..} 적용 (수렴까지)

• 외부 람다 내부 :

  • {..}/[x;y]x (각 반복에서 업데이트 됨) 및 y 항목 (y는 값 목록이며 각 반복에서 항목을 사용함)에 대해 람다를 반복적으로 적용합니다. 이 경우 arg y는 !#x(카운트 x, 즉 배열의 인덱스까지)

  • @[x;y;:;x x y] 배열 x 수정 (인덱스 y에서 x [x [y]] 할당)

APL (Dyalog Unicode) , 26 바이트 ^SBCS

필요 ⎕IO←0

{m⊣{m[⍵]←m[m[⍵]]}¨⍳≢m←⍵}⍣≡

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