假设我们有一个长度为n的数组$\texttt{ps}$，其中的指针指向该数组中的某个位置：“ 指针跳跃 ”过程将把每个指针都设置为其指向的指针所指向的位置。$n$

出于此挑战的目的，指针是数组元素的（从零开始）索引，这意味着数组中的每个元素都将大于或等于$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]}$$

因此，在“ 指针跳跃 ” 迭代之后，我们得到数组[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]

JavaScript，36个字节

修改原始输入数组。

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

在线尝试

Haskell，56个字节

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

Haskell和就地更新是不匹配的。

在线尝试！

Python 2，53字节

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

在线尝试！

-6感谢HyperNeutrino。

更改l为适当的结果。

C ++ 14（gcc），61个字节

作为未命名的通用lambda。需要类似的顺序容器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}}}

在线尝试！

-15感谢BMO

JavaScript（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#

在线尝试！

Japt，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

Java 8，105 54字节

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

修改输入数组，而不是返回一个新的数组以节省字节。

只需修改数组即可-51字节 $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没有用，因为每个人都g可以访问原始的U而不是在每个步骤中对其进行修改。适当地保留不同的组件也会花费少量的字节。

说明：

           #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（clang），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字节

-2个字节，感谢@digEmAll读取规则。

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次结束之前。证明留给读者。

Common Lisp，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)

在线尝试！

Clojure，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))))))

在线尝试！

Perl 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字节

Clojure，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上应用lambda {..}（直到收敛）

• 内部外部lambda：

  • {..}/[x;y]在x（每次迭代时更新）和y项（y是值列表，并在每次迭代中使用一个项）上迭代地应用lambda。在这种情况下，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←⍵}⍣≡

在线尝试！