Предположим, у нас есть массив длины с указателями, указывающими на какое-то место в массиве: процесс « прыжка с указателем » установит каждый указатель на то место, на которое указывает указатель.$\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 благодаря ГиперНейтрино .

Изменяет 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);}

Попробуйте онлайн!

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

Изменяет массив ввода вместо того, чтобы возвращать новый для сохранения байтов.

$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раз. К тому времени устойчивое состояние будет достигнуто наверняка, на самом деле к концу 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

Ничего особенного. Использует идею модуля в других ответах.

К, 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←⍵}⍣≡

Попробуйте онлайн!