Biz dizi olduğunu varsayalım uzunluğu "süreci: dizideki bir konuma işaret işaretçilerle işaretçi atlama konuma için noktalarına işaretçi her işaretçi ayarlayacaktır".$\texttt{ps}$$n$

Bu zorluğun amacı için bir işaretçi, dizinin bir elemanının (sıfır temelli) dizinidir; bu, dizideki her elemanın eşit veya daha büyük ve küçük olacağı anlamına gelir . Bu gösterim kullanılarak işlem şu şekilde formüle edilebilir:$0$$n$

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

Bu, (bu zorluk için) işaretçilerin sırayla yerinde (yani ilk önce düşük endekslerde) güncellendiği anlamına gelir.

Örnek

Bir örnek üzerinde çalışalım, :$\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]}$$

Böylece bir " işaretçi atlama " yinelemesinden sonra dizisini .$\texttt{[4,1,3,1,1,3]}$

Meydan okuma

İndeksleri olan bir dizi göz önüne alındığında, dizi artık değişmeyene kadar yukarıda açıklanan işaretçi zıplamasını yineleyerek elde edilen dizi.

kurallar

Programınız / fonksiyonunuz aynı tip bir liste / vektör / dizi vb. Alır ve verir / verir.

• boş olmadığı garantilidir ve
• sadece girişleri içerdiği garanti edilir .$0 \leq p < n$

Çeşitler: seçebilirsiniz

• 1 tabanlı dizinlemeyi kullanmak veya
• Gerçek işaretçiler kullanmak,

bununla birlikte gönderiminizde bunu belirtmelisiniz.

Test durumları

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

Orijinal giriş dizisini değiştirir.

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

Çevrimiçi deneyin

Haskell, 56 bayt

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

Haskell ve yerinde güncellemeler kötü bir eşleşmedir.

Çevrimiçi deneyin!

Python 2 , 53 bayt

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

Çevrimiçi deneyin!

-6 HyperNeutrino'a teşekkürler .

Sonuçtaki lyerine geçer.

C ++ 14 (gcc) , 61 bayt

Adsız genel lambda olarak. Gibi sıralı kaplar gerektirir std::vector.

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

Çevrimiçi deneyin!

Swift , 68 53 bayt

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

Çevrimiçi deneyin!

-15 BMO sayesinde

JavaScript (ES6), 41 bayt

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

Çevrimiçi deneyin!

05AB1E (eski) , 8 bayt

ΔDvDyèNǝ

Çevrimiçi deneyin!

açıklama

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

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

Çevrimiçi deneyin!

Japt, 15 13 7 bayt

Orijinal giriş dizisini değiştirir.

££hYXgU

Deneyin (değiştirilen girişi konsola yazmak için ek baytlar)

££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 bayt

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

Girdileri kaydetmek için yenisini döndürmek yerine girdi dizisini değiştirir.

$length^2$

Çevrimiçi deneyin.

Açıklama:

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 bayt

®
£hYUgX
eV ?U:ß

Tüm test durumlarını deneyin

Bu, daha kısa olması gerektiğini hissediyor, ancak ne yazık ki, benim ilk düşüncem UmgUişe yaramadı çünkü her biri , her adımda değiştirmek yerine gorijinali görüyor U. Farklı bileşenlerin uygun bir şekilde korunması, bir avuç bayt için de maliyetlidir.

Açıklama:

           #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 bit, 49 44 bayt

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

Çevrimiçi deneyin!

İşaretçiler kullanır.

Tamsayılı 50 45 bayt :

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

Çevrimiçi deneyin!

Ruby , 37 34 bayt

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

Çevrimiçi deneyin!

Giriş dizisini yerinde değiştirerek döndürür.

Kırmızı , 63 bayt

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

Çevrimiçi deneyin!

Diziyi yerinde değiştirir

R , 60 58 bayt

Kuralları okumak için @digEmAll sayesinde -2 bayt.

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

Çevrimiçi deneyin!

1 endeksli.

n Giriş dizisinin uzunluğu.

rep(1:n,n)1:n nzamanları çoğaltır (örn. n=3 => 1,2,3,1,2,3,1,2,3)

Dizi nzamanları arasında dolaşın . Kararlı durum o zamana kadar kesin olarak sağlanacaktır, aslında n-1'inin sonunda sanırım. Prova okuyucuya bırakılmıştır.

Ortak Lisp, 59 58 bayt

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

Çevrimiçi deneyin!

Temiz , 80 bayt

import StdEnv

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

Çevrimiçi deneyin!

Clojure , 136 bayt

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

Çevrimiçi deneyin!

Perl 5, 35 34 26 bayt

yakınsaklığın en fazla sayıdaki yineleme sayısı için erişilebileceği gerçeğini kullanarak

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

26 bayt

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

34 bayt

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

35 bayt

Clojure , 88 bayt

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

Çevrimiçi deneyin!

Kömür , 16 bayt

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı bir versiyonudur. Maalesef, tüm normal haritalama işlevleri sadece dizinin bir kopyası üzerinde çalışır, sonuçta sadece öğeleri atlamak yerine öğelere izin verirler, bu nedenle kodun her şeyi manuel olarak yapması gerekir. Açıklama:

Ｆθ

Her bir eleman için iç çevrimi bir kez tekrarlayın. Bu sadece sonucun stabilize olmasını sağlar.

ＦＬθ

Dizi endeksleri üzerinden döngü.

§≔θκ§θ§θκ

Dizi öğesini geçerli dizinde bulun, diziyi dizine eklemek için kullanın ve geçerli öğeyi bu değerle değiştirin.

Ｉθ

Öğeleri dizeye dönüştürün ve her birini kendi satırlarına örtülü olarak yazdırın.

F #, 74 73 bayt

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

Özel birşey yok. Diğer cevaplarda görülen modül fikrini kullanır.

K, 27 Bayt

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

• {..}/ lambda {..} 'ı arg üzerinde uygular (yakınsamaya kadar)

• dış lambda içinde:

  • {..}/[x;y]lambda'yı yinelemeli x üzerine uygular (her yinelemede güncellenir) ve y öğesi (y bir değer listesidir ve her yinelemede bir öğe kullanır). Bu durumda arg y 'dır !#x(til sayısı x, yani dizinin indeksleridir).

  • @[x;y;:;x x y] x dizisini değiştir (y dizininde x [x [y]] ata)

APL (Dyalog Unicode) , 26 bayt ^SBCS

gerektirir ⎕IO←0

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

Çevrimiçi deneyin!