Припустимо, у нас є масив довжини із вказівниками, що вказують на якесь місце в масиві: Процес " стрибки вказівника " встановить кожен вказівник на місце, на яке вказує вказівник.$\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]}$$

Отже, після однієї ітерації « стрибка » ми отримуємо масив .$\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 байт

Як безіменна родова лямбда. Потрібні послідовні контейнери типу 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 завдяки БМО

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

Змінює вхідний масив замість повернення нового для збереження байтів.

$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 (кланг) , 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. Стаціонарний стан буде досягнуто тоді точно, фактично до кінця п ятого разу, я думаю. Доказ залишається читачеві.

Лист звичайний, 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

Нічого особливого. Використовує ідею модуля, яку бачите в інших відповідях.

К, 27 байт

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

• {..}/ застосовується лямбда {..} над arg (до конвергенції)

• всередині зовнішньої лямбда:

  • {..}/[x;y]застосовується лямбда-ітераційно над x (оновлюється при кожній ітерації) та елементом y (y - це список значень, і використовується елемент при кожній ітерації). У цьому випадку arg y є !#x(til count x, тобто індекси масиву)

  • @[x;y;:;x x y] змінити масив x (в індексі y призначити x [x [y]])

APL (Dyalog Unicode) , 26 байт ^SBCS

Вимагає ⎕IO←0

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

Спробуйте в Інтернеті!