Giả sử chúng ta có một mảng có độ dài với các con trỏ trỏ đến một số vị trí trong mảng: Quá trình " nhảy con trỏ " sẽ đặt mọi con trỏ tới vị trí mà con trỏ trỏ tới.$\texttt{ps}$$n$

Với mục đích của thử thách này, một con trỏ là chỉ số (dựa trên zero) của một phần tử của mảng, điều này ngụ ý rằng mọi phần tử trong mảng sẽ lớn hơn hoặc bằng và nhỏ hơn . Sử dụng ký hiệu này, quy trình có thể được xây dựng như sau:$0$$n$

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

Điều này có nghĩa (đối với thách thức này) rằng các con trỏ được cập nhật tại chỗ theo thứ tự liên tiếp (nghĩa là các chỉ số thấp hơn trước).

Thí dụ

Chúng ta hãy làm việc qua một ví dụ, :$\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]}$$

Vì vậy, sau một lần lặp lại " nhảy con trỏ ", chúng ta sẽ nhận được mảng .$\texttt{[4,1,3,1,1,3]}$

Thử thách

Đưa ra một mảng với các chỉ số đầu ra, mảng thu được bằng cách lặp lại bước nhảy được mô tả ở trên cho đến khi mảng không thay đổi nữa.

Quy tắc

Chương trình / hàm của bạn sẽ lấy và trả về / xuất cùng loại, một danh sách / vector / mảng, v.v.

• được đảm bảo không trống và
• được đảm bảo chỉ chứa các mục .$0 \leq p < n$

Các biến thể: Bạn có thể chọn

• để sử dụng lập chỉ mục dựa trên 1 hoặc
• sử dụng con trỏ thực tế,

tuy nhiên bạn nên đề cập đến điều này trong bài nộp của bạn.

Các trường hợp thử nghiệm

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

JavaScript, 36 byte

Sửa đổi mảng đầu vào ban đầu.

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

Dùng thử trực tuyến

Haskell, 56 byte

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

Haskell và cập nhật tại chỗ là một kết hợp xấu.

Hãy thử trực tuyến!

Python 2 , 53 byte

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

Hãy thử trực tuyến!

-6 nhờ HyperNeutrino .

Thay đổi lkết quả tại chỗ.

C ++ 14 (gcc) , 61 byte

Như lambda chung không tên. Yêu cầu container tuần tự như thế nào std::vector.

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

Hãy thử trực tuyến!

Swift , 68 53 byte

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

Hãy thử trực tuyến!

-15 cảm ơn BMO

JavaScript (ES6), 41 byte

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

Hãy thử trực tuyến!

05AB1E (di sản) , 8 byte

ΔDvDyèNǝ

Hãy thử trực tuyến!

Giải trình

Δ          # 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 byte

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

Hãy thử trực tuyến!

Japt, 15 13 7 byte

Sửa đổi mảng đầu vào ban đầu.

££hYXgU

Hãy thử nó (các byte bổ sung là để ghi đầu vào đã sửa đổi vào bàn điều khiển)

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

Java 8, 105 54 byte

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

Sửa đổi mảng đầu vào thay vì trả về một mảng mới để lưu byte.

$length^2$

Hãy thử trực tuyến.

Giải trình:

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 byte

®
£hYUgX
eV ?U:ß

Hãy thử tất cả các trường hợp thử nghiệm

Điều này cảm thấy như nó nên ngắn hơn, nhưng thật không may, suy nghĩ ban đầu của UmgUtôi không hoạt động vì mỗi lần gtruy cập vào bản gốc Uthay vì sửa đổi nó ở mỗi bước. Việc bảo quản các thành phần khác nhau cũng tốn một số byte.

Giải trình:

           #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 (tiếng kêu) , 32 bit, 49 44 byte

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

Hãy thử trực tuyến!

Sử dụng con trỏ.

50 45 byte với số nguyên:

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

Hãy thử trực tuyến!

Ruby , 37 34 byte

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

Hãy thử trực tuyến!

Trả về bằng cách sửa đổi mảng đầu vào tại chỗ.

Màu đỏ , 63 byte

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

Hãy thử trực tuyến!

Sửa đổi mảng tại chỗ

R , 60 58 byte

-2 byte nhờ @digEmAll để đọc các quy tắc.

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

Hãy thử trực tuyến!

1 chỉ mục.

n là chiều dài của mảng đầu vào.

rep(1:n,n)nhân rộng 1:n nthời gian (ví dụ n=3 => 1,2,3,1,2,3,1,2,3)

Lặp lại qua các nlần mảng . Tôi chắc chắn sẽ đạt được trạng thái ổn định vào lúc đó, thực tế là vào cuối lần thứ n thông qua tôi nghĩ. Bằng chứng được để lại cho người đọc.

Lisp thường gặp, 59 58 byte

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

Hãy thử trực tuyến!

Sạch , 80 byte

import StdEnv

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

Hãy thử trực tuyến!

Clojure , 136 byte

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

Hãy thử trực tuyến!

Perl 5, 35 34 26 byte

sử dụng thực tế là sự hội tụ đạt được nhiều nhất cho số lần lặp kích thước

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

26 byte

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

34 byte

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

35 byte

Clojure , 88 byte

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

Hãy thử trực tuyến!

Than , 16 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Đáng buồn thay, tất cả các hàm ánh xạ thông thường chỉ hoạt động trên một bản sao của mảng với kết quả là chúng chỉ hoán vị các phần tử chứ không phải nhảy chúng, vì vậy mã phải làm mọi thứ bằng tay. Giải trình:

Ｆθ

Lặp lại vòng lặp bên trong một lần cho mỗi phần tử. Điều này chỉ đảm bảo rằng kết quả ổn định.

ＦＬθ

Lặp lại các chỉ số mảng.

§≔θκ§θ§θκ

Lấy phần tử mảng tại chỉ mục hiện tại, sử dụng phần tử đó để lập chỉ mục vào mảng và thay thế phần tử hiện tại bằng giá trị đó.

Ｉθ

Truyền các phần tử thành chuỗi và in ngầm từng dòng trên dòng riêng của chúng.

F #, 74 73 byte

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

Không có gì đặc biệt. Sử dụng ý tưởng mô-đun nhìn thấy trong các câu trả lời khác.

K, 27 byte

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

• {..}/ áp dụng lambda {..} trên arg (cho đến khi hội tụ)

• bên trong lambda bên ngoài:

  • {..}/[x;y]áp dụng lambda lặp đi lặp lại trên x (được cập nhật ở mỗi lần lặp) và một mục của y (y là danh sách các giá trị và sử dụng một mục ở mỗi lần lặp). Trong trường hợp này arg y là !#x(til Count x, nghĩa là các chỉ mục của mảng)

  • @[x;y;:;x x y] sửa đổi mảng x (tại chỉ mục y gán x [x [y]])

APL (Dyalog Unicode) , 26 byte ^SBCS

Đòi hỏi ⎕IO←0

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

Hãy thử trực tuyến!